add GUI with customtkinter and build to windows executable

gui.py

@@ -0,0 +1,622 @@
+# Build: build.bat ausfuehren (aus dem Projekt-Root).
+# Ergebnis: dist/AnwesenheitPDF/AnwesenheitPDF.exe + alle Abhaengigkeiten
+# Build-Artefakte: build/  (temporaer, nicht committen)
+
+import os
+import sys
+import threading
+from datetime import date
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import customtkinter as ctk
+from tkinter import messagebox, filedialog
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from src.config_loader import load_config
+from src.excel_reader import (
+    extract_attendance,
+    extract_persons,
+    extract_year_from_filename,
+)
+from src.pdf_filler import fill_pdf
+from src.validators import validate
+
+
+# ---------------------------------------------------------------------------
+# Module-level helpers
+# ---------------------------------------------------------------------------
+
+def _resource_path(relative: str) -> Path:
+    """Absolute path to a bundled asset. Handles PyInstaller onefile mode."""
+    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+        return Path(sys._MEIPASS) / relative
+    return Path(__file__).parent / relative
+
+
+def _runtime_dir() -> Path:
+    """Root directory for runtime folders (input/, output/, template/)."""
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).parent
+    return Path(__file__).parent
+
+
+def _scan_input_folder() -> Optional[Path]:
+    """Return the single .xlsx in input/, or None if 0 or >1 found."""
+    folder = _runtime_dir() / "input"
+    if not folder.exists():
+        return None
+    files = list(folder.glob("*.xlsx"))
+    return files[0] if len(files) == 1 else None
+
+
+def _scan_template_folder() -> Optional[Path]:
+    """Return the single .pdf in template/, or None if 0 or >1 found."""
+    folder = _runtime_dir() / "template"
+    if not folder.exists():
+        return None
+    files = list(folder.glob("*.pdf"))
+    return files[0] if len(files) == 1 else None
+
+
+def _count_output_pdfs(config: Dict[str, Any]) -> int:
+    """Count .pdf files in the configured output directory."""
+    out_dir = _runtime_dir() / config.get("output_dir", "output")
+    if not out_dir.exists():
+        return 0
+    return len(list(out_dir.glob("*.pdf")))
+
+
+def _build_month_keys(config: Dict[str, Any]) -> List[str]:
+    """Return deduplicated month keys from config (preserves insertion order)."""
+    seen: set = set()
+    keys: List[str] = []
+    for k, v in config.get("month_mapping", {}).items():
+        if v not in seen:
+            seen.add(v)
+            keys.append(k)
+    return keys
+
+
+# ---------------------------------------------------------------------------
+# Startup: load config once
+# ---------------------------------------------------------------------------
+
+ctk.set_appearance_mode("System")
+ctk.set_default_color_theme("blue")
+
+try:
+    _CONFIG: Dict[str, Any] = load_config()
+    _CONFIG_ERROR: Optional[str] = None
+except Exception as _exc:
+    _CONFIG = {}
+    _CONFIG_ERROR = str(_exc)
+
+_MONTH_KEYS: List[str] = _build_month_keys(_CONFIG)
+
+
+# ---------------------------------------------------------------------------
+# Application
+# ---------------------------------------------------------------------------
+
+class AnwesenheitApp(ctk.CTk):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.title("Anwesenheit PDF Generator")
+        self.geometry("720x680")
+        self.resizable(False, False)
+
+        icon_path = _resource_path("assets/icon.ico")
+        if icon_path.exists():
+            self.iconbitmap(str(icon_path))
+
+        # Internal state
+        self._excel_path: Optional[Path] = None
+        self._template_path: Optional[Path] = None
+        self._out_dir: Optional[Path] = None
+
+        # Build UI sections
+        self._build_input_section()
+        self._build_button_section()
+        self._build_preview_section()
+        self._build_log_section()
+
+        # Auto-scan after event loop starts
+        self.after(100, self._scan_and_validate)
+
+    # ------------------------------------------------------------------
+    # UI builders
+    # ------------------------------------------------------------------
+
+    def _build_input_section(self) -> None:
+        frame = ctk.CTkFrame(self)
+        frame.pack(fill="x", padx=16, pady=(16, 0))
+        frame.columnconfigure(2, weight=1)  # value column expands
+
+        BTN_W = 32
+
+        # Row 0: Excel file
+        ctk.CTkLabel(frame, text="Excel-Datei:", width=110, anchor="w").grid(
+            row=0, column=0, padx=(12, 4), pady=6, sticky="w"
+        )
+        ctk.CTkButton(
+            frame, text="\U0001f4c2", width=BTN_W, height=28,
+            command=self._browse_excel,
+        ).grid(row=0, column=1, padx=(0, 6), pady=6)
+        self._lbl_excel = ctk.CTkLabel(frame, text="Suche\u2026", anchor="w")
+        self._lbl_excel.grid(row=0, column=2, padx=(0, 12), pady=6, sticky="ew")
+
+        # Row 1: Template
+        ctk.CTkLabel(frame, text="Template:", width=110, anchor="w").grid(
+            row=1, column=0, padx=(12, 4), pady=6, sticky="w"
+        )
+        ctk.CTkButton(
+            frame, text="\U0001f4c2", width=BTN_W, height=28,
+            command=self._browse_template,
+        ).grid(row=1, column=1, padx=(0, 6), pady=6)
+        self._lbl_template = ctk.CTkLabel(frame, text="Suche\u2026", anchor="w")
+        self._lbl_template.grid(row=1, column=2, padx=(0, 12), pady=6, sticky="ew")
+
+        # Row 2: Month dropdown
+        ctk.CTkLabel(frame, text="Monat:", width=110, anchor="w").grid(
+            row=2, column=0, padx=(12, 4), pady=6, sticky="w"
+        )
+        self._month_var = ctk.StringVar(value=_MONTH_KEYS[0] if _MONTH_KEYS else "")
+        self._month_menu = ctk.CTkOptionMenu(
+            frame,
+            values=_MONTH_KEYS or ["\u2013"],
+            variable=self._month_var,
+            command=lambda _: self._on_month_changed(),
+            width=150,
+        )
+        self._month_menu.grid(row=2, column=2, padx=(0, 12), pady=6, sticky="w")
+
+        # Row 3: Output dir
+        out_label = str((_runtime_dir() / _CONFIG.get("output_dir", "output")).resolve())
+        ctk.CTkLabel(frame, text="Ausgabe:", width=110, anchor="w").grid(
+            row=3, column=0, padx=(12, 4), pady=6, sticky="w"
+        )
+        ctk.CTkButton(
+            frame, text="\U0001f4c2", width=BTN_W, height=28,
+            command=self._open_output_folder,
+        ).grid(row=3, column=1, padx=(0, 6), pady=6)
+        ctk.CTkLabel(frame, text=out_label, anchor="w").grid(
+            row=3, column=2, padx=(0, 12), pady=6, sticky="ew"
+        )
+
+        # Row 4: Output warning + "Ordner leeren" link (hidden when 0)
+        warning_row = ctk.CTkFrame(frame, fg_color="transparent")
+        warning_row.grid(row=4, column=2, padx=(0, 12), pady=(0, 6), sticky="ew")
+        self._lbl_warning = ctk.CTkLabel(
+            warning_row, text="", anchor="w", text_color="orange"
+        )
+        self._lbl_warning.pack(side="left")
+        self._lbl_clear_link = ctk.CTkLabel(
+            warning_row, text="", anchor="w",
+            text_color="#EF4444", cursor="hand2",
+        )
+        self._lbl_clear_link.pack(side="left", padx=(6, 0))
+        self._lbl_clear_link.bind("<Button-1>", lambda _: self._confirm_clear_output())
+
+    def _build_button_section(self) -> None:
+        frame = ctk.CTkFrame(self)
+        frame.pack(fill="x", padx=16, pady=(8, 0))
+        self._btn_generate = ctk.CTkButton(
+            frame,
+            text="Generieren",
+            state="disabled",
+            command=self._start_generate,
+            width=180,
+            height=40,
+        )
+        self._btn_generate.pack(pady=12)
+
+    def _build_preview_section(self) -> None:
+        frame = ctk.CTkFrame(self)
+        frame.pack(fill="x", padx=16, pady=(8, 0))
+
+        ctk.CTkLabel(frame, text="Vorschau", font=ctk.CTkFont(weight="bold")).grid(
+            row=0, column=0, columnspan=4, padx=12, pady=(8, 2), sticky="w"
+        )
+
+        fields = [
+            ("Datei:", "_pv_datei"),
+            ("Jahr:", "_pv_jahr"),
+            ("Monat:", "_pv_monat"),
+            ("Antragsnummer:", "_pv_antrag"),
+            ("Ort:", "_pv_ort"),
+            ("Erstelldatum:", "_pv_datum"),
+            ("Teilnehmer:", "_pv_teilnehmer"),
+            ("Fehler:", "_pv_fehler"),
+        ]
+
+        for i, (text, attr) in enumerate(fields):
+            row = 1 + i // 2
+            col_lbl = (i % 2) * 2
+            col_val = col_lbl + 1
+            ctk.CTkLabel(frame, text=text, width=110, anchor="w").grid(
+                row=row, column=col_lbl, padx=(12, 2), pady=3, sticky="w"
+            )
+            lbl = ctk.CTkLabel(frame, text="–", anchor="w", width=220)
+            lbl.grid(row=row, column=col_val, padx=(0, 8), pady=3, sticky="w")
+            setattr(self, attr, lbl)
+
+    def _build_log_section(self) -> None:
+        frame = ctk.CTkFrame(self)
+        frame.pack(fill="both", expand=True, padx=16, pady=(8, 16))
+        frame.rowconfigure(1, weight=1)
+        frame.columnconfigure(0, weight=1)
+
+        ctk.CTkLabel(frame, text="Log", font=ctk.CTkFont(weight="bold")).grid(
+            row=0, column=0, padx=12, pady=(8, 2), sticky="w"
+        )
+        self._log_box = ctk.CTkTextbox(
+            frame,
+            font=ctk.CTkFont(family="Courier New", size=11),
+            state="disabled",
+        )
+        self._log_box.grid(row=1, column=0, padx=12, pady=(0, 12), sticky="nsew")
+        # Configure clickable-link tag and bind events on underlying tk.Text
+        tb = self._log_box._textbox
+        tb.tag_config("pdf_link", foreground="#4FC3F7", underline=True)
+        tb.bind("<Button-1>", self._on_log_click)
+        tb.bind("<Motion>", self._on_log_motion)
+
+    # ------------------------------------------------------------------
+    # Log helpers
+    # ------------------------------------------------------------------
+
+    def _log(self, text: str) -> None:
+        self._log_box.configure(state="normal")
+        self._log_box.insert("end", text + "\n")
+        self._log_box.see("end")
+        self._log_box.configure(state="disabled")
+
+    def _log_ok(self, text: str) -> None:
+        """Insert an [OK] line styled as a clickable PDF link."""
+        tb = self._log_box._textbox
+        tb.configure(state="normal")
+        tb.insert("end", text + "\n")
+        insert_line = int(tb.index("end").split(".")[0]) - 1
+        tb.tag_add("pdf_link", f"{insert_line}.0", f"{insert_line}.end")
+        tb.see("end")
+        tb.configure(state="disabled")
+
+    def _clear_log(self) -> None:
+        self._log_box.configure(state="normal")
+        self._log_box.delete("1.0", "end")
+        self._log_box.configure(state="disabled")
+
+    def _on_log_click(self, event) -> None:
+        tb = self._log_box._textbox
+        idx = tb.index(f"@{event.x},{event.y}")
+        line_start = tb.index(f"{idx} linestart")
+        line_end = tb.index(f"{idx} lineend")
+        line = tb.get(line_start, line_end).strip()
+        if line.startswith("[OK]") and self._out_dir:
+            # Format: "[OK] filename.pdf  (i/total)"
+            rest = line[4:].strip()
+            filename = rest.split("  (")[0].strip()
+            pdf_path = self._out_dir / filename
+            if pdf_path.exists():
+                os.startfile(str(pdf_path))
+
+    def _on_log_motion(self, event) -> None:
+        tb = self._log_box._textbox
+        idx = tb.index(f"@{event.x},{event.y}")
+        line_start = tb.index(f"{idx} linestart")
+        line_end = tb.index(f"{idx} lineend")
+        line = tb.get(line_start, line_end).strip()
+        tb.configure(cursor="hand2" if line.startswith("[OK]") else "")
+
+    # ------------------------------------------------------------------
+    # Output folder
+    # ------------------------------------------------------------------
+
+    def _open_output_folder(self) -> None:
+        out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        os.startfile(str(out_dir))
+
+    # ------------------------------------------------------------------
+    # Preview helpers
+    # ------------------------------------------------------------------
+
+    def _clear_preview(self) -> None:
+        for attr in (
+            "_pv_datei", "_pv_jahr", "_pv_monat", "_pv_antrag",
+            "_pv_ort", "_pv_datum", "_pv_teilnehmer", "_pv_fehler",
+        ):
+            getattr(self, attr).configure(text="–", text_color=("gray10", "gray90"))
+
+    # ------------------------------------------------------------------
+    # Output warning
+    # ------------------------------------------------------------------
+
+    def _refresh_output_warning(self) -> None:
+        count = _count_output_pdfs(_CONFIG)
+        if count > 0:
+            self._lbl_warning.configure(
+                text=f"⚠  {count} PDF-Datei(en) bereits in output/"
+            )
+            self._lbl_clear_link.configure(text="(Ordner leeren)")
+        else:
+            self._lbl_warning.configure(text="")
+            self._lbl_clear_link.configure(text="")
+
+    def _confirm_clear_output(self) -> None:
+        out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
+        count = _count_output_pdfs(_CONFIG)
+        if count == 0:
+            return
+        confirmed = messagebox.askyesno(
+            "Ordner leeren",
+            f"{count} PDF-Datei(en) in output/ l\u00f6schen?\n\nDieser Vorgang kann nicht r\u00fcckg\u00e4ngig gemacht werden.",
+            icon="warning",
+            parent=self,
+        )
+        if confirmed:
+            for f in out_dir.glob("*.pdf"):
+                try:
+                    f.unlink()
+                except OSError:
+                    pass
+            self._refresh_output_warning()
+
+    # ------------------------------------------------------------------
+    # File browse helpers
+    # ------------------------------------------------------------------
+
+    def _browse_excel(self) -> None:
+        path = filedialog.askopenfilename(
+            title="Excel-Datei ausw\u00e4hlen",
+            filetypes=[("Excel-Dateien", "*.xlsx"), ("Alle Dateien", "*.*")],
+        )
+        if not path:
+            return
+        self._excel_path = Path(path)
+        self._lbl_excel.configure(
+            text=self._excel_path.name, text_color=("gray10", "gray90")
+        )
+        self._btn_generate.configure(state="disabled")
+        self._clear_preview()
+        self._clear_log()
+        if self._template_path and self._month_var.get():
+            threading.Thread(target=self._run_validate, daemon=True).start()
+
+    def _browse_template(self) -> None:
+        path = filedialog.askopenfilename(
+            title="Template-PDF ausw\u00e4hlen",
+            filetypes=[("PDF-Dateien", "*.pdf"), ("Alle Dateien", "*.*")],
+        )
+        if not path:
+            return
+        self._template_path = Path(path)
+        self._lbl_template.configure(
+            text=self._template_path.name, text_color=("gray10", "gray90")
+        )
+        self._btn_generate.configure(state="disabled")
+        self._clear_preview()
+        self._clear_log()
+        if self._excel_path and self._month_var.get():
+            threading.Thread(target=self._run_validate, daemon=True).start()
+
+    # ------------------------------------------------------------------
+    # Event handlers
+    # ------------------------------------------------------------------
+
+    def _on_month_changed(self) -> None:
+        self._btn_generate.configure(state="disabled")
+        self._clear_preview()
+        self._clear_log()
+        self._scan_and_validate()
+
+    def _scan_and_validate(self) -> None:
+        if _CONFIG_ERROR:
+            self._log(f"[FEHLER] config.json: {_CONFIG_ERROR}")
+            return
+
+        # Scan input/
+        self._excel_path = _scan_input_folder()
+        input_folder = _runtime_dir() / "input"
+        if self._excel_path:
+            self._lbl_excel.configure(
+                text=self._excel_path.name, text_color=("gray10", "gray90")
+            )
+        elif not input_folder.exists() or not list(input_folder.glob("*.xlsx")):
+            self._lbl_excel.configure(
+                text="Keine .xlsx in input/ gefunden", text_color="red"
+            )
+        else:
+            n = len(list(input_folder.glob("*.xlsx")))
+            self._lbl_excel.configure(
+                text=f"Mehrere Dateien gefunden ({n}) — nur eine erlaubt",
+                text_color="red",
+            )
+
+        # Scan template/
+        self._template_path = _scan_template_folder()
+        template_folder = _runtime_dir() / "template"
+        if self._template_path:
+            self._lbl_template.configure(
+                text=self._template_path.name, text_color=("gray10", "gray90")
+            )
+        elif not template_folder.exists() or not list(template_folder.glob("*.pdf")):
+            self._lbl_template.configure(
+                text="Keine .pdf in template/ gefunden", text_color="red"
+            )
+        else:
+            n = len(list(template_folder.glob("*.pdf")))
+            self._lbl_template.configure(
+                text=f"Mehrere Dateien gefunden ({n}) — nur eine erlaubt",
+                text_color="red",
+            )
+
+        # Refresh output warning
+        self._refresh_output_warning()
+
+        # Start validation thread if all inputs are ready
+        if self._excel_path and self._template_path and self._month_var.get():
+            threading.Thread(target=self._run_validate, daemon=True).start()
+
+    # ------------------------------------------------------------------
+    # Validation (background thread)
+    # ------------------------------------------------------------------
+
+    def _run_validate(self) -> None:
+        excel_file = str(self._excel_path)
+        month = self._month_var.get()
+        result: Dict[str, Any] = {
+            "errors": [],
+            "year": 0,
+            "persons": [],
+            "month": month,
+            "exception": None,
+        }
+
+        try:
+            result["errors"] = validate(excel_file, month)
+        except Exception as exc:
+            result["exception"] = str(exc)
+            self.after(0, self._on_validate_done, result)
+            return
+
+        try:
+            result["year"] = extract_year_from_filename(excel_file, _CONFIG)
+        except Exception as exc:
+            result["errors"].append(f"Jahr nicht ermittelbar: {exc}")
+
+        try:
+            result["persons"] = extract_persons(excel_file, month, _CONFIG)
+        except Exception as exc:
+            result["errors"].append(f"Teilnehmer nicht lesbar: {exc}")
+
+        self.after(0, self._on_validate_done, result)
+
+    def _on_validate_done(self, result: Dict[str, Any]) -> None:
+        if result.get("exception"):
+            self._log(f"[FEHLER] {result['exception']}")
+            self._btn_generate.configure(state="disabled")
+            return
+
+        errors: List[str] = result["errors"]
+        year: int = result["year"]
+        persons = result["persons"]
+        month: str = result["month"]
+
+        month_num = (_CONFIG.get("month_mapping") or {}).get(month, "??")
+        default_color = ("gray10", "gray90")
+
+        self._pv_datei.configure(
+            text=self._excel_path.name if self._excel_path else "–",
+            text_color=default_color,
+        )
+        self._pv_jahr.configure(
+            text=str(year) if year else "–", text_color=default_color
+        )
+        self._pv_monat.configure(
+            text=f"{month} ({month_num})", text_color=default_color
+        )
+        self._pv_antrag.configure(
+            text=_CONFIG.get("antragsnummer", "–"), text_color=default_color
+        )
+        self._pv_ort.configure(
+            text=_CONFIG.get("ort", "–"), text_color=default_color
+        )
+        self._pv_datum.configure(
+            text=date.today().strftime("%d.%m.%Y"), text_color=default_color
+        )
+        self._pv_teilnehmer.configure(
+            text=str(len(persons)), text_color=default_color
+        )
+
+        if errors:
+            self._pv_fehler.configure(text=str(len(errors)), text_color="red")
+            self._clear_log()
+            self._log("--- Validierungsfehler ---")
+            for err in errors:
+                self._log(f"  [!] {err}")
+            self._btn_generate.configure(state="disabled")
+        else:
+            self._pv_fehler.configure(text="0", text_color=default_color)
+            self._clear_log()
+            self._btn_generate.configure(state="normal")
+
+    # ------------------------------------------------------------------
+    # Generation
+    # ------------------------------------------------------------------
+
+    def _start_generate(self) -> None:
+        count = _count_output_pdfs(_CONFIG)
+        if count > 0:
+            answer = messagebox.askyesnocancel(
+                "Ausgabe-Verzeichnis nicht leer",
+                f"{count} PDF-Datei(en) bereits in output/ vorhanden.\n\n"
+                "Inhalt vor der Generierung löschen?",
+                parent=self,
+            )
+            if answer is None:   # Cancel
+                return
+            if answer:           # Yes → delete existing PDFs
+                out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
+                for f in out_dir.glob("*.pdf"):
+                    try:
+                        f.unlink()
+                    except OSError:
+                        pass
+
+        self._btn_generate.configure(state="disabled")
+        self._clear_log()
+        threading.Thread(target=self._run_generate, daemon=True).start()
+
+    def _run_generate(self) -> None:
+        excel_file = str(self._excel_path)
+        month = self._month_var.get()
+        success_count = 0
+        total = 0
+
+        try:
+            year = extract_year_from_filename(excel_file, _CONFIG)
+            persons = extract_persons(excel_file, month, _CONFIG)
+            total = len(persons)
+
+            out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
+            out_dir.mkdir(parents=True, exist_ok=True)
+            self._out_dir = out_dir
+
+            for i, person in enumerate(persons, 1):
+                try:
+                    attendance = extract_attendance(
+                        excel_file, month, person, year, _CONFIG
+                    )
+                    output_filename = f"{person.filename_safe_name}.pdf"
+                    output_path = out_dir / output_filename
+                    fill_pdf(attendance, self._template_path, output_path, _CONFIG)
+                    self.after(0, self._log_ok, f"[OK] {output_filename}  ({i}/{total})")
+                    success_count += 1
+                except Exception as exc:
+                    self.after(0, self._log, f"[FEHLER] {person.name}: {exc}")
+
+        except Exception as exc:
+            self.after(0, self._log, f"[FEHLER] {exc}")
+            self.after(0, self._on_generate_done, 0, 0)
+            return
+
+        self.after(0, self._on_generate_done, success_count, total)
+
+    def _on_generate_done(self, success: int, total: int) -> None:
+        self._log(f"\nFertig: {success}/{total} PDFs erzeugt.")
+        self._btn_generate.configure(state="normal")
+        self._refresh_output_warning()
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    app = AnwesenheitApp()
+    app.mainloop()