unnötiges Feld entfernt

.copilot/PLAN.md

@@ -1,24 +1,37 @@
 # Ziel
 
-Eine Python + Streamlit App für Windows, die aus einer Input-Excel-Datei (ein Sheet pro Monat mit Mitarbeiterdaten) und einem Excel-Template pro Mitarbeiter eine Excel-Datei generiert (ein Sheet pro Monat, befüllt mit dessen Daten).
+Eine Python + Streamlit App für Windows, die aus einer Input-Excel-Datei (ein Sheet pro Monat mit Mitarbeiterdaten) und einem **PDF-Template** pro Mitarbeiter eine **PDF-Datei** generiert (eine Seite pro Monat, befüllt mit dessen Daten).
 
-**Ansatz**: Verwendung von openpyxl für Single-Input-File + Streamlit-UI.
+**Ansatz**: openpyxl für Input-Parsing + PyMuPDF (fitz) für PDF-Generierung + Streamlit-UI.
+
+> **Hintergrund**: Das ursprüngliche Excel-Template war teilweise schreibgeschützt und konnte nicht mit openpyxl befüllt werden.
+> Daher wurde das Template als PDF exportiert. Im PDF wurden alle zu befüllenden Textstellen mit einem Platzhalter
+> im Format `{Feldname}_Field` markiert (z. B. `Antragsnummer_Field`, `Name_Field`). Die App sucht nach diesen
+> `_Field`-Markern und ersetzt sie durch die echten Daten.
 
 # Aufgabe
 
 Erstelle eine Windows App in dessen Oberfläche aus folgenden Bestandteilen aufgebaut ist:
 - mittels einem DropDown-Menü kann eine Datei aus dem inputfolder gewählt werden
-- mittels einem DropDown-Menü kann ein Template aus dem Templatefolder gewählt werden
+- mittels einem DropDown-Menü kann ein PDF-Template aus dem Templatefolder gewählt werden
 - ein Button um den Vorgang zu starten
 
-Die Funktion der App besteht darin, das Templatefile mit Daten aus dem Input-File zu befüllen.
+Die Funktion der App besteht darin, das Template-PDF mit Daten aus dem Input-File zu befüllen.
-Im Inputfile ist für alle Monate eines Jahres eine Liste aller Mitarbeitenden und in den Spalten alle Daten zur Befüllung des Template files.
+Im Inputfile ist für alle Monate eines Jahres eine Liste aller Mitarbeitenden und in den Spalten alle Daten zur Befüllung des Templates.
 
 # Aufbau Input Datei
 
 - In der Input Datei ist für jeden Monat eines Jahres ein Sheet gespeichert.
 - In jedem Sheet befindet sich eine Tabelle (felder speichern in Input Schema json) mit Mitarbeitenden.
-- Für jeden Mitarbeitenden soll aus dem Template eine neue ExcelDatei erzeugt werden, welche auch wieder für jeden Monat ein Sheet des Templates enthält und alle Daten des Mitarbeiters für dieses Monat aus der Inputliste enthält.
+- Für jeden Mitarbeitenden wird ein PDF erzeugt, das für jeden Monat eine Seite enthält, befüllt mit den Daten des Mitarbeiters für diesen Monat.
+
+# Aufbau PDF-Template
+
+- Das PDF-Template ist eine einseitige PDF-Datei, generiert aus der ursprünglichen XLSX-Vorlage.
+- Jede zu befüllende Textstelle enthält einen Platzhalter: den Feldnamen gefolgt von `_Field`
+  (z. B. `Antragsnummer_Field`, `Name_Field`, `Stellenanteil in %_Field`, …).
+- Die App sucht im PDF nach allen `_Field`-Texten, ermittelt deren Position und Schriftgröße,
+  und ersetzt sie durch die tatsächlichen Datenwerte.
 
 # README
 
@@ -30,15 +43,14 @@ In der README.md ist ein kleine Doku wie das Programm zu benutzen ist und welche
 
 ### Phase 1: Projekt-Grundgerüst & Konfiguration
 
-1. **`requirements.txt` befüllen** — `streamlit`, `openpyxl`
+1. **`requirements.txt` befüllen** — `streamlit`, `openpyxl`, `PyMuPDF`
 2. **`config/settings.ini` befüllen** — Pfade, Standardwerte
-   - Abschnitte: `[paths]` (input_dir, template_dir, output_dir), `[output]` (filename_pattern)
+   - Abschnitte: `[paths]` (input_dir, template_dir, output_dir), `[output]` (filename_pattern → `.pdf`)
 3. **`config/input-fields.json` Schema definieren** — Spalten der Input-Tabelle mit ihren exakten Überschriften
-   - Wird durch Analyse der Datei `input/2025 JM.xlsx` ermittelt: Spaltenposition (A, B, C…) und die exakte Spaltenüberschrift aus Zeile 1 der jeweiligen Sheets
    - JSON-Array mit `column` (Spaltenbuchstabe), `field_name` (exakte Überschrift aus der Excel-Tabelle), `type` (string|number|date), `required` (true|false)
-4. **`config/output-fields.json` Mapping definieren** — Welche Input-Felder (exakte Spaltenüberschrift) in welche Template-Zellen geschrieben werden
+4. **`config/output-fields.json` Mapping definieren** — Welche Input-Felder in das PDF geschrieben werden
-   - JSON-Array mit `source_field` (exakte Spaltenüberschrift aus der Input-Tabelle, wie in input-fields.json definiert), `target_cell` (Zelladresse im Template, z.B. "A17"), `format` (optional, z.B. "dd.mm.yyyy")
+   - JSON-Array mit `source_field` (exakte Spaltenüberschrift aus der Input-Tabelle), `format` (optional, z. B. "dd.mm.yyyy")
-   - Muss durch Analyse des Templates `template/Tätigkeitsnachweise Stellenförderung.xlsx` ermittelt werden (welche Zellen sind zu befüllen?)
+   - Der Platzhalter im PDF ist immer `{source_field}_Field` – kein explizites `target_cell` mehr nötig
 
 ### Phase 2: Core-Module (`src/`)
 
@@ -50,62 +62,52 @@ In der README.md ist ein kleine Doku wie das Programm zu benutzen ist und welche
    - `load_input_schema()`: liest `config/input-fields.json`
    - `load_output_mapping()`: liest `config/output-fields.json`
    - `get_available_input_files()`: listet `.xlsx`-Dateien in `input/`
-   - `get_available_templates()`: listet `.xlsx`-Dateien in `template/`
+   - `get_available_templates()`: listet `.pdf`-Dateien in `template/`
-7. **`src/parser.py`** — Input-Datei einlesen
+7. **`src/parser.py`** — Input-Datei einlesen (unverändert: openpyxl für XLSX-Input)
    - `parse_input_file(filepath, schema)`: öffnet Workbook, iteriert über alle Sheets (Monate)
    - Extrahiert Monat/Jahr aus Sheet-Namen oder Sheet-Inhalt
    - Für jedes Sheet: liest Zeilen anhand des Schemas, erzeugt `EmployeeRecord`-Liste
-   - Rückgabe: `dict[str, list[EmployeeRecord]]` (key = Mitarbeiter-Name)
+   - Rückgabe: `list[EmployeeRecord]`
 
-### Phase 3: Writer & Validierung
+### Phase 3: Writer & Validierung (PDF-basiert)
 
-8. **`src/writer.py`** — Output generieren
+8. **`src/writer.py`** — PDF-Output generieren (NEU: PyMuPDF)
    - `generate_activity_reports(employee_records, template_path, mapping, config)`:
+     - **Pre-Scan**: Öffnet das Template-PDF einmal und sucht nach allen `_Field`-Platzhaltern,
+       ermittelt deren Position (bounding box) und Schriftgröße
      - Gruppiert Records nach Mitarbeiter
-     - Für jeden Mitarbeiter: lädt Template, erstellt für jeden Monat ein Sheet (kopiert Template-Sheet)
+     - Für jeden Mitarbeiter:
-     - Befüllt Zielzellen gemäß output-fields.json Mapping
+       - Erstellt ein neues PDF
-     - Benennt Sheets nach Monat (z.B. "01_Januar", "02_Februar", …)
+       - Für jeden Monats-Record: fügt eine Kopie der Template-Seite ein
-     - Speichert als `{nachname}_{vorname}_{YYYY}_Tätigkeitsnachweis.xlsx` in `output/`
+       - Ersetzt alle `_Field`-Platzhalter durch die tatsächlichen Daten (redact + insert_text)
-9. **`src/validator.py`** — Eingabevalidierung
+       - Speichert als `{nachname}_{vorname}_Tätigkeitsnachweis.pdf` in `output/`
-   - `validate_input_file(filepath, schema)`: prüft Datei-Existenz, Sheet-Anzahl, Spalten laut Schema
+9. **`src/validator.py`** — Eingabevalidierung (angepasst für PDF)
-   - `validate_template(template_path, mapping)`: prüft ob alle target_cells im Template existieren
+   - `validate_input_file(filepath, schema)`: unverändert (prüft XLSX-Input)
+   - `validate_template(template_path, mapping)`: prüft ob alle `_Field`-Platzhalter im PDF gefunden werden
 
 ### Phase 4: Streamlit UI
 
-10. **`app.py`** — Streamlit-Oberfläche
+10. **`app.py`** — Streamlit-Oberfläche (angepasst für PDF-Templates)
     - Layout:
       - Titel + Beschreibung
       - `st.selectbox` für Input-Datei (aus `input/`-Folder)
         - **Sofort bei Auswahl**: Validierung + Parsing der Datei
         - Anzeige: Anzahl gefundener Mitarbeiter, Auflistung aller enthaltenen Antragsnummern
-        - Bei Fehlern: `st.error` mit Details
+      - `st.selectbox` für PDF-Template (aus `template/`-Folder)
-      - `st.selectbox` für Template (aus `template/`-Folder)
+        - **Sofort bei Auswahl**: Validierung des PDF-Templates (Prüfung aller `_Field`-Marker)
-        - **Sofort bei Auswahl**: Validierung des Templates gegen `output-fields.json`
+        - Anzeige: Anzahl gefundener Platzhalter-Felder
-        - Anzeige: Anzahl gefundener Zielfelder (target_cells), fehlende/fehlerhafte Zellen
-        - Bei Fehlern: `st.warning` mit Details
       - **Mitarbeiter-Liste** (erscheint nach erfolgreicher Input-Validierung)
         - `st.multiselect` mit allen gefundenen Mitarbeiternamen, standardmäßig alle vorselektiert
-        - Nicht selektierte Mitarbeiter werden bei der Generierung übersprungen
-        - Zeigt: „X von Y Mitarbeitern ausgewählt"
       - `st.button("Tätigkeitsnachweise generieren")`
     - Bei Button-Click:
       1. Filtere Employee Records auf selektierte Mitarbeiter
-      2. Generiere Activity Reports nur für selektierte Mitarbeiter und speichere in `output/`
+      2. Generiere PDFs nur für selektierte Mitarbeiter und speichere in `output/`
-      3. Zeige Erfolgsmeldung mit Liste der erstellten Dateien via `st.success`
+      3. Zeige Erfolgsmeldung mit Liste der erstellten PDF-Dateien
-    - Status-Anzeige mit `st.spinner` und `st.progress`
 
 ### Phase 5: Start-Skript & Doku
 
-11. **`start.bat`** — Windows Batch-Startdatei
+11. **`start.bat`** — Windows Batch-Startdatei (unverändert)
-    - Prüft ob Python verfügbar ist
-    - Installiert Requirements (falls nötig)
-    - Startet `streamlit run app.py`
 12. **`README.md` aktualisieren** — Vollständige Doku
-    - Setup-Anleitung (Python, venv, pip install)
-    - Konfiguration (settings.ini, input-fields.json, output-fields.json)
-    - Bedienung (Datei auswählen, Template wählen, Button klicken)
-    - Erwartetes Input-Format (Spalten, monatliche Sheets)
-    - Output-Beschreibung (Dateiname, Struktur)
 
 ---
 
@@ -113,19 +115,17 @@ In der README.md ist ein kleine Doku wie das Programm zu benutzen ist und welche
 
 | Datei | Aktion |
 |-------|--------|
-| `requirements.txt` | Neu befüllen |
+| `requirements.txt` | `PyMuPDF` hinzufügen |
-| `config/settings.ini` | Neu befüllen |
+| `config/settings.ini` | filename_pattern auf `.pdf` ändern |
-| `config/input-fields.json` | Neu befüllen (nach Analyse Input-Datei) |
+| `config/output-fields.json` | `target_cell` entfernen (wird durch `_Field`-Marker ersetzt) |
-| `config/output-fields.json` | Neu befüllen (nach Analyse Template) |
+| `src/writer.py` | Komplett neu: PDF-basierte Generierung mit PyMuPDF |
-| `src/__init__.py` | Neu (leer) |
+| `src/validator.py` | `validate_template` für PDF anpassen |
-| `src/models.py` | Neu |
+| `src/config.py` | `get_available_templates` auf `.pdf` umstellen |
-| `src/config.py` | Neu |
+| `app.py` | Template-Validierung für PDF anpassen |
-| `src/parser.py` | Neu |
+| `coldrun.py` | An PDF-Template anpassen |
-| `src/writer.py` | Neu |
+| `tests/test_e2e.py` | Tests für PDF-Output anpassen |
-| `src/validator.py` | Neu |
+| `.copilot/PLAN.md` | Dieser Plan – aktualisiert |
-| `app.py` | Neu |
+| `.copilot/TASKS.md` | Aufgabenliste – aktualisiert |
-| `start.bat` | Neu |
-| `README.md` | Überschreiben mit vollständiger Doku |
 
 ## Projektstruktur
 
@@ -139,25 +139,28 @@ In der README.md ist ein kleine Doku wie das Programm zu benutzen ist und welche
 ├── config/
 │   ├── settings.ini        ← Einstellungen der App
 │   ├── input-fields.json   ← Schema der Inputdaten-Tabelle
-│   └── output-fields.json  ← Schema der Outputdaten-Tabelle
+│   └── output-fields.json  ← Mapping: Input-Feld → PDF-Platzhalter
-├── output/                 ← Zielordner für generierte Dateien
+├── output/                 ← Zielordner für generierte PDF-Dateien
+├── template/
+│   └── *.pdf               ← PDF-Template mit _Field-Platzhaltern
 ├── src/
 │   ├── __init__.py
 │   ├── models.py
 │   ├── config.py
 │   ├── parser.py
-│   ├── writer.py
+│   ├── writer.py           ← PDF-basierte Generierung (PyMuPDF)
 │   └── validator.py
 ├── app.py                  ← Streamlit-App
+├── coldrun.py              ← CLI Cold-Run
 ├── start.bat               ← Windows batch zum Start der App
 ├── README.md               ← README für Programmbenutzer
-└── requirements.txt        ← streamlit, openpyxl
+└── requirements.txt        ← streamlit, openpyxl, PyMuPDF
 ```
 
 ## Verifikation
 
-1. **Input-Datei-Analyse**: `2025 JM.xlsx` mit openpyxl öffnen, Sheet-Namen prüfen, exakte Spaltenüberschriften aus Zeile 1 jedes Sheets auslesen → `input-fields.json` ableiten (Spaltenbuchstabe + original Feldname)
+1. **Input-Datei-Analyse**: `2025 JM.xlsx` mit openpyxl öffnen, Sheet-Namen prüfen, Spaltenüberschriften validieren
-2. **Template-Analyse**: `Tätigkeitsnachweise Stellenförderung.xlsx` öffnen, belegte/freie Zellen inspizieren, die befüllt werden sollen → `output-fields.json` ableiten (Mapping: Input-Spaltenüberschrift → Template-Zelladresse)
+2. **PDF-Template-Analyse**: `Tätigkeitsnachweise Stellenförderung.pdf` mit PyMuPDF öffnen, alle `_Field`-Platzhalter suchen → mit `output-fields.json` abgleichen
-3. **Unit-Test**: App mit vorhandener Input-Datei und Template ausführen, prüfen ob Output-Dateien korrekt befüllt sind
+3. **Unit-Test**: App mit vorhandener Input-Datei und PDF-Template ausführen, prüfen ob Output-PDFs korrekt befüllt sind
-4. **Edge Cases**: Leere Input-Zeilen, fehlende Monate, Mitarbeiter ohne Vorname, Sonderzeichen in Namen
+4. **Edge Cases**: Leere Input-Zeilen, fehlende Monate, Mitarbeiter ohne Vorname, Sonderzeichen in Namen, Umlaute im PDF
 ```

.copilot/TASKS.md

@@ -1,27 +1,47 @@
-# Aufgaben: Tätigkeitsnachweis-Generator (Streamlit App)
+# Aufgaben: Tätigkeitsnachweis-Generator (Streamlit App) – PDF-Migration
 
-## 🔍 Analyse ✅
+> **Migration**: Das XLSX-Template war schreibgeschützt und wurde durch ein PDF-Template ersetzt.
-- [x] **A1**: Input-Datei `input/2025 JM.xlsx` analysieren → Sheet-Namen, exakte Spaltenüberschriften (Zeile 1), Spaltenpositionen (A, B, C…), Beispiel-Daten
+> Alle `_Field`-Platzhalter im PDF werden durch echte Daten ersetzt.
-- [x] **A2**: Template `template/Tätigkeitsnachweise Stellenförderung.xlsx` analysieren → zu befüllende Zielzellen identifizieren (Zelladresse + erwarteter Inhalt)
 
-## ⚙️ Konfiguration ✅
+## 🔄 Migration: XLSX → PDF Template ✅
-- [x] **K1**: `config/input-fields.json` mit Spaltenschema befüllen — `column` (A, B…), `field_name` (exakte Überschrift aus Excel), `type`, `required`
-- [x] **K2**: `config/output-fields.json` mit Zell-Mappings befüllen — `source_field` (exakte Spaltenüberschrift aus input-fields.json), `target_cell`, `format`
-- [x] **K3**: `config/settings.ini` mit Pfaden und Einstellungen befüllen
 
-## 🧱 Core-Module ✅
+- [x] **M1**: `requirements.txt` → `PyMuPDF` hinzufügen
-- [x] **C1**: `requirements.txt` befüllen (streamlit, openpyxl)
+- [x] **M2**: `config/settings.ini` → `filename_pattern` auf `.pdf`-Endung ändern
-- [x] **C2**: `src/__init__.py` + `src/models.py` — Datenklassen
+- [x] **M3**: `config/output-fields.json` → `target_cell` entfernen, `pdf_field` hinzufügen (Mapping source_field → PDF-Platzhalter-Name)
-- [x] **C3**: `src/config.py` — Konfigurations-Loader
+- [x] **M4**: `src/config.py` → `get_available_templates()` auf `.pdf`-Dateien umstellen
-- [x] **C4**: `src/parser.py` — Input-Datei parsen
+- [x] **M5**: `src/validator.py` → `validate_template()` für PDF angepasst (prüft `_Field`-Platzhalter via PyMuPDF)
-- [x] **C5**: `src/validator.py` — Eingabevalidierung
+- [x] **M6**: `src/writer.py` → Komplett neu: PDF-basierte Generierung mit PyMuPDF
-- [x] **C6**: `src/writer.py` — Output generieren
+  - Pre-Scan: Alle `_Field`-Platzhalter im Template-PDF finden (Position, Schriftgröße)
+  - Für jeden Mitarbeiter: neues PDF, pro Monat eine Seite (Template-Kopie), `_Field`-Texte redacten + ersetzen
+  - Dateiname: `{nachname}_{vorname}_Tätigkeitsnachweis.pdf`
+- [x] **M7**: `app.py` → Template-Validierung für PDF angepasst (Dropdown zeigt `.pdf`, Validierung prüft `_Field`-Marker)
+- [x] **M8**: `coldrun.py` → An PDF-Template angepasst
+- [x] **M9**: `tests/test_e2e.py` → Tests für PDF-Output umgeschrieben (PyMuPDF statt openpyxl zur Output-Validierung)
+- [x] **M10**: `.copilot/PLAN.md` und `.copilot/TASKS.md` aktualisiert
 
-## 🖥️ UI & Start ✅
+## 🔍 Analyse (abgeschlossen)
-- [x] **U1**: `app.py` — Streamlit-Oberfläche (Input-Selektion: validieren & Mitarbeiteranzahl + Antragsnummern anzeigen; Template-Selektion: validieren & Zielfelder anzeigen; Mitarbeiter-Multiselect zum Ein-/Ausschließen)
+- [x] **A1**: Input-Datei `input/2025 JM.xlsx` analysiert
-- [x] **U2**: `start.bat` — Windows Batch-Startdatei
+- [x] **A2**: PDF-Template `template/Tätigkeitsnachweise Stellenförderung.pdf` liegt vor (mit `_Field`-Platzhaltern)
-- [x] **U3**: `README.md` — vollständige Dokumentation
 
-## ✅ Test ✅
+## ⚙️ Konfiguration (migriert)
-- [x] **T1**: App mit vorhandener Input-Datei und Template testen — 19 Tätigkeitsnachweise erfolgreich generiert
+- [x] **K1**: `config/input-fields.json` — unverändert gültig
-- [x] **T2**: Edge Cases prüfen (leere Zeilen, Sonderzeichen, fehlende Monate) — Umlaute, Sonderzeichen in Namen, "Alle Rollen"-Sheet korrekt behandelt
+- [x] **K2**: `config/output-fields.json` — `target_cell` entfernt, `pdf_field` hinzugefügt
+- [x] **K3**: `config/settings.ini` — filename_pattern auf `.pdf`
+
+## 🧱 Core-Module
+- [x] **C1**: `requirements.txt` — streamlit, openpyxl, PyMuPDF
+- [x] **C2**: `src/__init__.py` + `src/models.py` — `OutputMapping` um `pdf_field` erweitert
+- [x] **C3**: `src/config.py` — Template-Suche auf `.pdf` umgestellt
+- [x] **C4**: `src/parser.py` — unverändert
+- [x] **C5**: `src/validator.py` — `validate_template()` für PDF via PyMuPDF
+- [x] **C6**: `src/writer.py` — Komplett neu mit PyMuPDF (redact + insert_text)
+
+## 🖥️ UI & Start
+- [x] **U1**: `app.py` — PDF-Template-Validierung angepasst
+- [x] **U2**: `start.bat` — unverändert
+- [x] **U3**: `coldrun.py` — An PDF angepasst, funktioniert
+- [x] **U4**: `README.md` — vorhanden
+
+## ✅ Test
+- [x] **T1**: E2E-Test mit realer Input-Datei und PDF-Template → 5/5 Tests bestanden
+- [x] **T2**: Edge Cases — Umlaute korrekt im PDF, fehlende Marker (Ort/Datum) werden übersprungen

README.md

@@ -22,6 +22,20 @@ streamlit run app.py
 
 Oder einfach `start.bat` (Windows) bzw. `./start.sh` (macOS/Linux) ausführen.
 
+## Cold Run – Headless-Generierung
+
+`coldrun.py` erzeugt ohne GUI einen Tätigkeitsnachweis für die erste Person –
+automatisch mit der ersten Input- und Template-Datei. Ergebnis wird auf macOS
+im Finder geöffnet.
+
+```bash
+# Kommandozeile
+.venv/bin/python coldrun.py
+
+# oder per Doppelklick (macOS)
+coldrun.command
+```
+
 ## Bedienung
 
 1. **Input-Datei wählen** – Dropdown zeigt alle `.xlsx`-Dateien aus dem `input/`-Ordner
@@ -69,4 +83,25 @@ Mapping von Input-Feldern auf Template-Zellen:
 
 - Pro selektiertem Mitarbeiter wird eine `.xlsx`-Datei erstellt
 - Jeder Monat wird als eigenes Sheet (Kopie des Templates) eingefügt
-- Dateiname: `{Nachname}_{Vorname}_Tätigkeitsnachweis.xlsx`
+- Dateiname: `{Nachname}_{Vorname}_Tätigkeitsnachweis.xlsx`
+
+## Tests
+
+End-to-End-Tests parsen die reale Input-Datei (`input/2025 JM.xlsx`) und das reale
+Template (`template/Tätigkeitsnachweise Stellenförderung.xlsx`) und validieren
+den gesamten Generierungs-Workflow.
+
+```bash
+# Test-Abhängigkeiten installieren
+.venv/bin/pip install pytest
+
+# Tests ausführen
+.venv/bin/python -m pytest tests/test_e2e.py -v
+```
+
+Die Tests prüfen:
+- Vorhandensein der Input- und Template-Dateien
+- Korrekte Parsierung (168 Datensätze, 19 Personen)
+- Vollständige Pipeline für die erste Person („Draßdo, Cornelia"): 12 Monats-Sheets
+  mit allen Zellinhalten (Antragsnummer, Name, Stellenanteil, Qualifikation, Monat,
+  Funktion, Tätigkeit, Ort, Datum)

app.py

@@ -157,7 +157,7 @@ with col2:
     st.subheader("2. Template")
     template_files = get_available_templates(app_config)
     if not template_files:
-        st.warning("Keine .xlsx-Dateien im template/-Ordner gefunden.")
+        st.warning("Keine .pdf-Dateien im template/-Ordner gefunden.")
         selected_template = None
     else:
         # Lock-Files herausfiltern
@@ -202,9 +202,9 @@ with col2:
             st.session_state.template_validated = False
         else:
             st.session_state.template_validated = True
-            found = tpl_result.info.get("found_target_cells", 0)
+            found = tpl_result.info.get("found_fields", 0)
-            total = tpl_result.info.get("total_target_cells", 0)
+            total = tpl_result.info.get("total_fields", 0)
-            st.success(f"✅ {found}/{total} Zielfelder gefunden")
+            st.success(f"✅ {found}/{total} Platzhalter-Felder gefunden")
             if tpl_result.warnings:
                 st.markdown(
                     '<div style="border:2px solid #f39c12; border-radius:8px; padding:8px 12px; '

coldrun.bat

@@ -0,0 +1,46 @@
+@echo off
+title Tätigkeitsnachweis-Generator – Cold Run
+echo ========================================
+echo   Cold Run – Headless-Generierung
+echo ========================================
+echo.
+
+:: Prüfe ob Python verfügbar ist
+where python >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Python wurde nicht gefunden.
+    echo Bitte installiere Python 3.9 oder neuer von https://python.org
+    pause
+    exit /b 1
+)
+
+echo [INFO] Python gefunden:
+python --version
+
+:: Prüfe ob venv existiert, sonst erstelle
+if not exist ".venv\Scripts\python.exe" (
+    echo [FEHLER] Virtuelle Umgebung nicht gefunden.
+    echo Bitte zuerst start.bat ausführen, um das Projekt einzurichten.
+    pause
+    exit /b 1
+)
+
+:: Aktiviere venv und installiere Abhängigkeiten
+call .venv\Scripts\activate.bat
+echo [INFO] Stelle sicher, dass Abhängigkeiten installiert sind...
+pip install -r requirements.txt --quiet
+if %ERRORLEVEL% neq 0 (
+    echo [FEHLER] Konnte Abhängigkeiten nicht installieren.
+    pause
+    exit /b 1
+)
+
+:: Starte Cold Run
+echo.
+echo [INFO] Starte Cold Run – generiere Tätigkeitsnachweis für erste Person...
+echo.
+python coldrun.py
+
+echo.
+echo [INFO] Cold Run abgeschlossen.
+pause

coldrun.command

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Doppelklickbares Cold-Run-Script für macOS
+# Nimmt automatisch die erste Input-Datei + erstes Template und erzeugt
+# einen Tätigkeitsnachweis für die erste gelistete Person – ohne GUI.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+VENV_DIR=".venv"
+
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    echo "[FEHLER] Virtuelle Umgebung nicht gefunden."
+    echo "Bitte zuerst start.command ausführen, um das Projekt einzurichten."
+    read -p "Drücke Enter zum Beenden..."
+    exit 1
+fi
+
+echo "[INFO] Stelle sicher, dass Abhängigkeiten installiert sind…"
+"$VENV_DIR/bin/pip" install -r requirements.txt --quiet 2>/dev/null || true
+
+echo ""
+"$VENV_DIR/bin/python" coldrun.py
+
+echo ""
+read -p "Drücke Enter zum Beenden..."

coldrun.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Cold-Run Tätigkeitsnachweis-Generator.
+
+Nimmt automatisch die erste Input-Datei und das erste Template,
+erzeugt einen Tätigkeitsnachweis für die erste gelistete Person
+und öffnet das Ergebnis (macOS) – ohne GUI, ohne Fragen.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+# Projekt-Root
+PROJECT_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.config import (
+    load_settings,
+    load_input_schema,
+    load_output_mapping,
+    get_available_input_files,
+    get_available_templates,
+)
+from src.parser import parse_input_file, group_by_employee, get_unique_employees
+from src.validator import validate_input_file, validate_template
+from src.writer import generate_activity_reports
+
+
+def main():
+    print("=" * 50)
+    print("  Tätigkeitsnachweis-Generator (Cold Run)")
+    print("=" * 50)
+    print()
+
+    # ── Konfiguration laden ──────────────────────────────────────────
+    config_dir = PROJECT_ROOT / "config"
+    config = load_settings(config_dir, PROJECT_ROOT)
+    config.input_schema = load_input_schema(config_dir)
+    config.output_mapping = load_output_mapping(config_dir)
+
+    # ── Erste Input-Datei ermitteln ───────────────────────────────────
+    input_files = get_available_input_files(config)
+    if not input_files:
+        print("[FEHLER] Keine .xlsx-Dateien im input/-Ordner gefunden.")
+        return 1
+
+    input_file = input_files[0]
+    input_path = Path(config.input_dir) / input_file
+    print(f"[INFO] Input-Datei:  {input_file}")
+
+    # ── Erstes Template ermitteln ─────────────────────────────────────
+    template_files = get_available_templates(config)
+    if not template_files:
+        print("[FEHLER] Keine .pdf-Dateien im template/-Ordner gefunden.")
+        return 1
+
+    template_file = template_files[0]
+    template_path = Path(config.template_dir) / template_file
+    print(f"[INFO] Template:     {template_file}")
+
+    # ── Template validieren ───────────────────────────────────────────
+    print()
+    print("[INFO] Validiere PDF-Template…")
+    tpl_result = validate_template(template_path, config.output_mapping)
+    if not tpl_result.is_valid:
+        for err in tpl_result.errors:
+            print(f"[FEHLER] {err}")
+        return 1
+    found = tpl_result.info.get("found_fields", "?")
+    total = tpl_result.info.get("total_fields", "?")
+    print(f"[OK]   {found}/{total} Platzhalter im Template gefunden.")
+
+    # ── Input validieren ──────────────────────────────────────────────
+    print()
+    print("[INFO] Validiere Input-Datei…")
+    inp_result = validate_input_file(input_path, config.input_schema, config.month_sheet_pattern)
+    if not inp_result.is_valid:
+        for err in inp_result.errors:
+            print(f"[FEHLER] {err}")
+        return 1
+    if inp_result.warnings:
+        for warn in inp_result.warnings:
+            print(f"[WARN]  {warn}")
+
+    # ── Input parsen ──────────────────────────────────────────────────
+    print()
+    print("[INFO] Parse Input-Datei…")
+    records = parse_input_file(
+        filepath=input_path,
+        schema=config.input_schema,
+        month_sheet_pattern=config.month_sheet_pattern,
+        skip_empty_name=config.skip_empty_name,
+        skip_empty_antragsnummer=config.skip_empty_antragsnummer,
+    )
+
+    employees = get_unique_employees(records)
+    print(f"[INFO] {len(records)} Einträge für {len(employees)} Personen gefunden.")
+
+    # ── Erste Person ermitteln ────────────────────────────────────────
+    grouped = group_by_employee(records)
+    first_person = sorted(grouped.keys())[0]
+    first_records = grouped[first_person]
+    print(f"[INFO] Erste Person:  {first_person} ({len(first_records)} Monate)")
+
+    # ── Reports generieren ────────────────────────────────────────────
+    print()
+    print("[INFO] Generiere Tätigkeitsnachweis…")
+    single_person = {first_person: first_records}
+    output_dir = Path(config.output_dir)
+    generated = generate_activity_reports(
+        employee_records=single_person,
+        template_path=template_path,
+        mapping=config.output_mapping,
+        output_dir=output_dir,
+        filename_pattern=config.filename_pattern,
+    )
+
+    output_file = generated[0]
+    print(f"[OK]   Erstellt: {output_file.name}")
+    print(f"      Pfad:     {output_file}")
+
+    # ── Datei öffnen (macOS) ──────────────────────────────────────────
+    if sys.platform == "darwin":
+        print()
+        print("[INFO] Öffne Datei im Finder…")
+        subprocess.run(["open", str(output_file)], check=False)
+
+    print()
+    print("=" * 50)
+    print("  Fertig.")
+    print("=" * 50)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

config/output-fields.json

@@ -1,12 +1,10 @@
 [
-  {"source_field": "Antragsnummer", "target_cell": "B3", "format": null},
+  {"source_field": "Antragsnummer",           "pdf_field": "Antragsnummer_Field",         "format": null},
-  {"source_field": "Name", "target_cell": "B17", "format": null},
+  {"source_field": "Name",                    "pdf_field": "Name_Field",                   "format": null},
-  {"source_field": "Stellenanteil in %", "target_cell": "R17", "format": null},
+  {"source_field": "Stellenanteil in %",      "pdf_field": "Stellenanteil_Field",          "format": null},
-  {"source_field": "Qualifikation", "target_cell": "B21", "format": null},
+  {"source_field": "Qualifikation",           "pdf_field": "Qualifikation_Field",          "format": null},
-  {"source_field": "Monat (MM.JJ)", "target_cell": "R21", "format": null},
+  {"source_field": "Monat (MM.JJ)",           "pdf_field": "Monat_Field",                  "format": null},
-  {"source_field": "Funktion", "target_cell": "B25", "format": null},
+  {"source_field": "Funktion",                "pdf_field": "Funktion_Field",               "format": null},
-  {"source_field": "Tätigkeit", "target_cell": "B31", "format": null},
+  {"source_field": "Tätigkeit",               "pdf_field": "Tätigkeiten_Field",            "format": null},
-  {"source_field": "Ort", "target_cell": "B95", "format": null},
+  {"source_field": "Datum",                   "pdf_field": "Datum_Field",                  "format": null}
-  {"source_field": "Ort 2", "target_cell": "B103", "format": null},
-  {"source_field": "Datum", "target_cell": "J95", "format": null}
 ]

config/settings.ini

@@ -4,7 +4,7 @@ template_dir = template
 output_dir = output
 
 [output]
-filename_pattern = {last_name}_{first_name}_Tätigkeitsnachweis.xlsx
+filename_pattern = {last_name}_{first_name}_Tätigkeitsnachweis.pdf
 
 [parsing]
 # Sheets whose names match these patterns are treated as monthly data sheets

requirements.txt

@@ -1,2 +1,3 @@
 streamlit>=1.28,<2.0
 openpyxl>=3.1,<4.0
+PyMuPDF>=1.23,<2.0

src/config.py

@@ -74,8 +74,8 @@ def get_available_input_files(config: AppConfig) -> list[str]:
 
 
 def get_available_templates(config: AppConfig) -> list[str]:
-    """Listet alle .xlsx-Dateien im template-Ordner."""
+    """Listet alle .pdf-Dateien im template-Ordner."""
-    return get_available_files(Path(config.template_dir))
+    return get_available_files(Path(config.template_dir), extension=".pdf")
 
 
 def is_month_sheet(sheet_name: str, pattern: str) -> bool:

src/models.py

@@ -47,8 +47,8 @@ class FieldSchema:
 class OutputMapping:
     """Definition eines Mappings aus output-fields.json."""
     source_field: str
-    target_cell: str
     format: Optional[str] = None
+    pdf_field: Optional[str] = None  # Name des _Field-Platzhalters im PDF (z.B. "Auftragsnummer_Field")
 
 
 @dataclass

src/validator.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 from typing import Optional
 
+import fitz  # PyMuPDF
 from openpyxl import load_workbook
 from openpyxl.utils import column_index_from_string
 
@@ -80,6 +81,49 @@ def validate_input_file(
     info["sheets_with_data"] = sheets_with_data
     wb.close()
 
+    # ── Dateninhalts-Prüfung: leere Pflichtfelder ───────────────────
+    required_fields = [f for f in schema if f.required]
+    if required_fields and sheets_with_data > 0:
+        # Mapping field_name → column index
+        field_col_map: dict[str, int] = {}
+        for f in required_fields:
+            field_col_map[f.field_name] = column_index_from_string(f.column) - 1
+        max_col = max(field_col_map.values()) + 1
+
+        # {field_name: {name1, name2, ...}} für leere Pflichtwerte
+        empty_by_field: dict[str, set[str]] = {f.field_name: set() for f in required_fields}
+
+        wb2 = load_workbook(filepath, data_only=True)
+        for sheet_name in wb2.sheetnames:
+            if not is_month_sheet(sheet_name, month_sheet_pattern):
+                continue
+            ws = wb2[sheet_name]
+            if ws.max_row < 2:
+                continue
+            for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=max_col, values_only=True):
+                name_val = str(row[field_col_map.get("Name", 0)] or "").strip() if len(row) > field_col_map.get("Name", 0) else ""
+                if not name_val:
+                    continue
+                for f in required_fields:
+                    col_idx = field_col_map[f.field_name]
+                    if col_idx < len(row):
+                        cell_val = str(row[col_idx] or "").strip() if row[col_idx] is not None else ""
+                        if not cell_val:
+                            empty_by_field[f.field_name].add(name_val)
+        wb2.close()
+
+        for field_name, names in empty_by_field.items():
+            if names:
+                sorted_names = sorted(names)
+                total = len(sorted_names)
+                preview = sorted_names[:5]
+                suffix = " …" if total > 5 else ""
+                warnings.append(
+                    f"Feld '{field_name}' ist leer bei {total} Person(en): "
+                    f"{', '.join(preview)}{suffix}"
+                )
+    # ──────────────────────────────────────────────────────────────────
+
     if sheets_with_data == 0:
         errors.append("Kein Sheet mit den erwarteten Spalten gefunden.")
 
@@ -96,9 +140,9 @@ def validate_template(
     mapping: list[OutputMapping],
 ) -> ValidationResult:
     """
-    Validiert ein Template:
+    Validiert ein PDF-Template:
     - Datei existiert
-    - Alle target_cells aus dem Mapping sind im Template vorhanden
+    - Alle _Field-Platzhalter (pdf_field) sind im PDF auf irgendeiner Seite vorhanden
     """
     errors: list[str] = []
     warnings: list[str] = []
@@ -109,37 +153,51 @@ def validate_template(
         return ValidationResult(is_valid=False, errors=errors)
 
     try:
-        wb = load_workbook(template_path, data_only=True)
+        doc = fitz.open(template_path)
     except Exception as e:
-        errors.append(f"Template konnte nicht geöffnet werden: {e}")
+        errors.append(f"PDF-Template konnte nicht geöffnet werden: {e}")
         return ValidationResult(is_valid=False, errors=errors)
 
-    info["sheet_names"] = wb.sheetnames
+    if doc.page_count == 0:
-
+        errors.append("PDF-Template enthält keine Seiten.")
-    # Wir validieren gegen das erste Sheet (üblicherweise das Haupt-Template)
+        doc.close()
-    if not wb.sheetnames:
-        errors.append("Template enthält keine Sheets.")
-        wb.close()
         return ValidationResult(is_valid=False, errors=errors)
 
-    ws = wb[wb.sheetnames[0]]
+    found_count = 0
+    missing_fields = []
 
-    found_cells = 0
-    missing_cells = []
     for m in mapping:
-        try:
+        if m.pdf_field is None:
-            cell = ws[m.target_cell]
+            continue  # Kein Marker erwartet
-            found_cells += 1
-        except (ValueError, KeyError):
-            missing_cells.append(m.target_cell)
 
-    info["found_target_cells"] = found_cells
+        # Suche auf allen Seiten
-    info["total_target_cells"] = len(mapping)
+        found_any = False
+        for page_num in range(doc.page_count):
+            found = doc[page_num].search_for(m.pdf_field)
+            if found:
+                found_any = True
+                break
 
-    if missing_cells:
+        if found_any:
-        errors.append(f"Zielfelder nicht im Template gefunden: {', '.join(missing_cells)}")
+            found_count += 1
+        else:
+            missing_fields.append(m.source_field)
+
+    # Zähle unique pdf_fields (nicht die source_fields, da Tätigkeit doppelt vorkommt)
+    unique_pdf_fields = set(m.pdf_field for m in mapping if m.pdf_field is not None)
+    total_pages = doc.page_count
+
+    doc.close()
+
+    info["found_fields"] = found_count
+    info["total_fields"] = len(unique_pdf_fields)
+    info["page_count"] = total_pages
+
+    if missing_fields:
+        errors.append(
+            f"Platzhalter nicht im PDF-Template gefunden: {', '.join(missing_fields)}"
+        )
 
-    wb.close()
     return ValidationResult(
         is_valid=len(errors) == 0,
         errors=errors,

src/writer.py

@@ -1,19 +1,22 @@
-"""Template-basierte Activity-Report-Generierung.
+"""PDF-basierte Activity-Report-Generierung.
 
-Verwendet ein Template mit bereits vor-duplizierten Sheets.
+Verwendet ein mehrseitiges PDF-Template mit _Field-Platzhaltern.
-Es werden KEINE Sheets programmatisch erzeugt oder kopiert – 
+Für jeden Mitarbeiter wird ein PDF erzeugt (alle Template-Seiten pro Monat).
-ausschließlich die vorhandenen Sheets mit Daten befüllt.
+Die _Field-Marker werden per PyMuPDF (fitz) gesucht und durch echte Daten ersetzt.
 """
 
 import calendar
 from pathlib import Path
 
-from openpyxl import load_workbook
+import fitz  # PyMuPDF
-from openpyxl.cell.cell import MergedCell
 
 from .models import EmployeeRecord, OutputMapping
 
 
+# ─────────────────────────────────────────────
+# Namens-Helfer
+# ─────────────────────────────────────────────
+
 def _split_name_for_filename(name: str) -> tuple[str, str]:
     """Teilt 'Nachname, Vorname' oder 'Vorname Nachname' in (Vorname, Nachname)."""
     cleaned = str(name or "").strip()
@@ -42,23 +45,6 @@ def _format_value(value, fmt: str | None) -> str:
     return str(value)
 
 
-def _set_cell_value(ws, target_cell: str, value) -> None:
-    """Setzt einen Wert in einer Zelle des Worksheets.
-    Behandelt MergedCells, indem in die Top-Left-Zelle des Merge-Bereichs geschrieben wird."""
-    try:
-        cell = ws[target_cell]
-        if isinstance(cell, MergedCell):
-            for merged_range in ws.merged_cells.ranges:
-                if cell.coordinate in merged_range:
-                    top_left = merged_range.min_row, merged_range.min_col
-                    ws.cell(row=top_left[0], column=top_left[1]).value = value
-                    return
-        else:
-            cell.value = value
-    except (ValueError, KeyError):
-        pass
-
-
 def _format_month_for_template(monat_str: str) -> str:
     """Konvertiert 'MM.JJ' zu 'MM.JJJJ'."""
     monat_str = monat_str.strip()
@@ -72,46 +58,186 @@ def _format_month_for_template(monat_str: str) -> str:
     return monat_str
 
 
-def _month_name(mi: int) -> str:
+# ─────────────────────────────────────────────
-    names = ["", "Januar", "Februar", "März", "April", "Mai", "Juni",
+# Daten-Extraktion aus EmployeeRecord
-             "Juli", "August", "September", "Oktober", "November", "Dezember"]
+# ─────────────────────────────────────────────
-    return names[mi] if 1 <= mi <= 12 else ""
 
-
+def _get_field_value(record: EmployeeRecord, employee_name: str, source_field: str) -> str:
-def _fill_sheet(ws, record: EmployeeRecord, employee_name: str, field_map: dict) -> None:
+    """Liefert den formatierten Wert für ein Feld im PDF."""
-    """Befüllt ein einzelnes Sheet mit den Daten eines EmployeeRecords."""
+    if source_field == "Monat (MM.JJ)":
-    for source_field, m in field_map.items():
+        return _format_month_for_template(record.monat)
-        if source_field == "Monat (MM.JJ)":
+    elif source_field == "Stellenanteil in %":
-            value = _format_month_for_template(record.monat)
+        return record.stellenanteil
-        elif source_field == "Stellenanteil in %":
+    elif source_field == "Name":
-            value = record.stellenanteil
+        return employee_name
-        elif source_field == "Name":
+    elif source_field == "Antragsnummer":
-            value = employee_name
+        return record.antragsnummer
-        elif source_field == "Antragsnummer":
+    elif source_field == "Qualifikation":
-            value = record.antragsnummer
+        return record.qualifikation
-        elif source_field == "Qualifikation":
+    elif source_field == "Funktion":
-            value = record.qualifikation
+        return record.funktion
-        elif source_field == "Funktion":
+    elif source_field == "Tätigkeit":
-            value = record.funktion
+        return record.taetigkeit
-        elif source_field == "Tätigkeit":
+    elif source_field in ("Ort", "Ort 2"):
-            value = record.taetigkeit
+        return "Dresden"
-        elif source_field in ("Ort", "Ort 2"):
+    elif source_field == "Datum":
-            value = "Dresden"
+        parts = record.monat.split(".")
-        elif source_field == "Datum":
+        if len(parts) == 2:
-            parts = record.monat.split(".")
+            try:
-            if len(parts) == 2:
                 month = int(parts[0])
                 year = int(parts[1])
                 last_day = calendar.monthrange(year, month)[1]
-                value = f"{last_day:02d}.{month:02d}.{year}"
+                return f"{last_day:02d}.{month:02d}.{year}"
-            else:
+            except (ValueError, IndexError):
-                value = ""
+                return ""
-        else:
+        return ""
-            continue
+    return ""
-        formatted = _format_value(value, m.format)
-        _set_cell_value(ws, m.target_cell, formatted)
 
 
+# ─────────────────────────────────────────────
+# PDF-Template Pre-Scan: _Field-Positionen auf ALLEN Seiten ermitteln
+# ─────────────────────────────────────────────
+
+def _scan_template_fields(
+    template_path: Path,
+    mapping: list[OutputMapping],
+) -> dict[str, dict]:
+    """
+    Scannt ALLE Seiten des PDF-Templates nach _Field-Platzhaltern.
+    Rückgabe: dict[pdf_field] → {source_field, page_num, rect, fontsize, fontname, ...}
+    Felder mit pdf_field=None werden übersprungen.
+    """
+    doc = fitz.open(template_path)
+
+    # Sammle alle pdf_field → source_field Zuordnungen
+    pdf_to_source: dict[str, str] = {}
+    for m in mapping:
+        if m.pdf_field is not None:
+            pdf_to_source[m.pdf_field] = m.source_field
+
+    field_info: dict[str, dict] = {}
+
+    # 1. Per search_for die Rechtecke aller PDF-Feld-Marker finden (alle Seiten)
+    for pdf_field, source_field in pdf_to_source.items():
+        found_any = False
+        for page_num in range(doc.page_count):
+            page = doc[page_num]
+            found = page.search_for(pdf_field)
+            if found:
+                field_info[pdf_field] = {
+                    "source_field": source_field,
+                    "page_num": page_num,
+                    "rect": found[0],
+                    "fontsize": 11,  # Fallback
+                    "fontname": "helv",
+                }
+                found_any = True
+                break  # erstes Vorkommen (seitenübergreifend)
+        if not found_any:
+            field_info[pdf_field] = None  # nicht gefunden
+
+    # 2. Schriftgrößen aus den Text-Details extrahieren (alle Seiten)
+    for page_num in range(doc.page_count):
+        page = doc[page_num]
+        text_dict = page.get_text("dict")
+        for block in text_dict.get("blocks", []):
+            if "lines" not in block:
+                continue
+            for line in block["lines"]:
+                for span in line["spans"]:
+                    text = span["text"].strip()
+                    if text.endswith("_Field") and text in field_info:
+                        info = field_info[text]
+                        if info is not None:
+                            info["fontsize"] = span["size"]
+                            info["fontname"] = span.get("font", "helv")
+                            info["rect"] = fitz.Rect(span["bbox"])
+
+    doc.close()
+    return field_info
+
+
+# ─────────────────────────────────────────────
+# Template-Seiten mit Daten befüllen
+# ─────────────────────────────────────────────
+
+def _fill_pdf_pages(
+    pages: list[fitz.Page],  # eine Page pro Template-Seite
+    record: EmployeeRecord,
+    employee_name: str,
+    mapping: list[OutputMapping],
+    field_info: dict[str, dict],
+) -> None:
+    """Befüllt alle Template-Seiten: redacted _Field-Platzhalter und fügt echte Daten ein."""
+    # Mehrzeilige Felder, die als Textbox (mit Zeilenumbruch) behandelt werden
+    MULTILINE_FIELDS = {"Tätigkeiten_Field", "Dienstreisen_Field"}
+    TEXTBOX_FONT_SCALE = 1      # Schriftgrößen-Faktor für Textboxen
+    TEXTBOX_WIDTH_PT = 400        # Breite der Textbox in Punkt
+    TEXTBOX_HEIGHT_PT = 120       # Höhe der Textbox in Punkt
+
+    for m in mapping:
+        if m.pdf_field is None:
+            continue
+
+        info = field_info.get(m.pdf_field)
+        if info is None:
+            continue  # Feld nicht im Template gefunden
+
+        page_num = info["page_num"]
+        if page_num >= len(pages):
+            continue
+
+        page = pages[page_num]
+        rect = info["rect"]
+        fontsize = info.get("fontsize", 11)
+
+        value = _get_field_value(record, employee_name, m.source_field)
+        formatted = _format_value(value, m.format)
+
+        # Platzhalter immer redacten, auch wenn kein Wert zum Einsetzen da ist
+        page.add_redact_annot(rect)
+        page.apply_redactions()
+
+        if not formatted:
+            continue
+
+        # Mehrzeilige Felder: insert_textbox mit Zeilenumbruch
+        if m.pdf_field in MULTILINE_FIELDS:
+            # Doppelte Leerzeilen entfernen
+            clean_text = "\n".join(
+                line for line in formatted.split("\n") if line.strip()
+            )
+            if not clean_text:
+                continue
+
+            # Rechteck für die Textbox: ausgehend vom Marker, nach rechts & unten erweitert
+            textbox_rect = fitz.Rect(
+                rect.x0,                     # links
+                rect.y0,                     # oben
+                rect.x0 + TEXTBOX_WIDTH_PT,  # rechts
+                rect.y0 + TEXTBOX_HEIGHT_PT, # unten
+            )
+            page.insert_textbox(
+                textbox_rect,
+                clean_text,
+                fontname="helv",
+                fontsize=fontsize * TEXTBOX_FONT_SCALE,
+                lineheight=1.5,
+                align=fitz.TEXT_ALIGN_LEFT,
+            )
+        else:
+            page.insert_text(
+                rect.bl,
+                formatted,
+                fontname="helv",
+                fontsize=fontsize,
+            )
+
+
+# ─────────────────────────────────────────────
+# Hauptfunktion: Reports generieren
+# ─────────────────────────────────────────────
+
 def generate_activity_reports(
     employee_records: dict[str, list[EmployeeRecord]],
     template_path: Path,
@@ -120,14 +246,14 @@ def generate_activity_reports(
     filename_pattern: str,
 ) -> list[Path]:
     """
-    Befüllt vor-duplizierte Template-Sheets mit Mitarbeiterdaten.
+    Erzeugt für jeden Mitarbeiter ein PDF.
-    Erzeugt KEINE neuen Sheets – verwendet ausschließlich die im Template
+    Pro Monat werden ALLE Template-Seiten kopiert und mit Daten befüllt.
-    bereits vorhandenen Sheet-Kopien.
     """
     output_dir.mkdir(parents=True, exist_ok=True)
     generated_files: list[Path] = []
 
-    field_map: dict[str, OutputMapping] = {m.source_field: m for m in mapping}
+    # Pre-Scan: Feld-Positionen auf allen Template-Seiten ermitteln
+    field_info = _scan_template_fields(template_path, mapping)
 
     for employee_name, records in employee_records.items():
         if not records:
@@ -140,31 +266,24 @@ def generate_activity_reports(
         filename = filename_pattern.format(first_name=safe_first, last_name=safe_last)
         output_path = output_dir / filename
 
-        wb = load_workbook(template_path)
         sorted_records = sorted(records, key=lambda r: r.month_index)
-        total_needed = len(sorted_records)
-        available_sheets = wb.worksheets
 
-        if len(available_sheets) < total_needed:
+        # Ergebnis-PDF erstellen
-            wb.close()
+        result_doc = fitz.open()
-            raise RuntimeError(
-                f"Template hat nur {len(available_sheets)} Sheets, "
-                f"aber {total_needed} werden benötigt für '{employee_name}'."
-            )
 
-        for idx, record in enumerate(sorted_records):
+        for record in sorted_records:
-            sheet = available_sheets[idx]
+            # Template frisch öffnen für jeden Monat
-            mi = record.month_index
+            temp_doc = fitz.open(template_path)
-            func_abbr = record.funktion[:3] if record.funktion else ""
+            pages = [temp_doc[i] for i in range(temp_doc.page_count)]
-            sheet.title = f"{mi:02d}_{_month_name(mi)}_{func_abbr}"[:31]
-            _fill_sheet(sheet, record, employee_name, field_map)
 
-        # Lösche überzählige Sheets (von hinten nach vorne)
+            _fill_pdf_pages(pages, record, employee_name, mapping, field_info)
-        for extra in reversed(available_sheets[total_needed:]):
-            wb.remove(extra)
 
-        wb.save(output_path)
+            # Alle modifizierten Seiten ins Ergebnis-PDF einfügen
-        wb.close()
+            result_doc.insert_pdf(temp_doc)
+            temp_doc.close()
+
+        result_doc.save(output_path)
+        result_doc.close()
         generated_files.append(output_path)
 
     return generated_files

test.command

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Doppelklickbares Test-Script für macOS (.command wird von Finder automatisch im Terminal geöffnet)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "========================================"
+echo "  Tätigkeitsnachweis-Generator – Tests"
+echo "========================================"
+echo ""
+
+VENV_DIR=".venv"
+
+if [[ ! -x "$VENV_DIR/bin/python" ]]; then
+    echo "[FEHLER] Virtuelle Umgebung nicht gefunden."
+    echo "Bitte zuerst start.command ausführen, um das Projekt einzurichten."
+    read -p "Drücke Enter zum Beenden..."
+    exit 1
+fi
+
+echo "[INFO] Stelle sicher, dass pytest installiert ist..."
+"$VENV_DIR/bin/pip" install pytest --quiet 2>/dev/null || true
+
+echo ""
+echo "[INFO] Führe End-to-End-Tests aus…"
+echo ""
+
+"$VENV_DIR/bin/python" -m pytest tests/test_e2e.py -v
+
+echo ""
+read -p "Drücke Enter zum Beenden..."

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests für den Tätigkeitsnachweis-Generator."""

tests/test_e2e.py

@@ -0,0 +1,220 @@
+"""End-to-End-Test: Reale Input-Datei + reales PDF-Template → PDF-Output für erste Person."""
+
+import sys
+from pathlib import Path
+
+import fitz  # PyMuPDF
+import pytest
+
+# Projekt-Root zum Python-Path hinzufügen
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.config import load_settings, load_input_schema, load_output_mapping
+from src.parser import parse_input_file, group_by_employee, get_unique_employees
+from src.writer import generate_activity_reports
+
+
+# ──────────────────────────────────────────────
+# Pfade zu den realen Fixture-Dateien
+# ──────────────────────────────────────────────
+
+CONFIG_DIR = PROJECT_ROOT / "config"
+INPUT_FILE = PROJECT_ROOT / "input" / "2025 JM.xlsx"
+TEMPLATE_FILE = PROJECT_ROOT / "template" / "Tätigkeitsnachweise Stellenförderung.pdf"
+
+
+def _load_app_config():
+    """Lädt die echte App-Konfiguration (Schema, Mapping, Settings)."""
+    config = load_settings(CONFIG_DIR, PROJECT_ROOT)
+    config.input_schema = load_input_schema(CONFIG_DIR)
+    config.output_mapping = load_output_mapping(CONFIG_DIR)
+    return config
+
+
+# ──────────────────────────────────────────────
+# Fixtures
+# ──────────────────────────────────────────────
+
+@pytest.fixture(scope="module")
+def app_config():
+    """Reale App-Konfiguration aus config/."""
+    return _load_app_config()
+
+
+@pytest.fixture(scope="module")
+def parsed_records(app_config):
+    """Geparste Records aus der realen Input-Datei."""
+    return parse_input_file(
+        filepath=INPUT_FILE,
+        schema=app_config.input_schema,
+        month_sheet_pattern=app_config.month_sheet_pattern,
+        skip_empty_name=app_config.skip_empty_name,
+        skip_empty_antragsnummer=app_config.skip_empty_antragsnummer,
+    )
+
+
+@pytest.fixture
+def output_dir(tmp_path):
+    """Temporäres Output-Verzeichnis."""
+    out = tmp_path / "output"
+    out.mkdir()
+    return out
+
+
+# ──────────────────────────────────────────────
+# Hilfsfunktion: Text aus PDF extrahieren
+# ──────────────────────────────────────────────
+
+def _get_pdf_text(pdf_path: Path) -> str:
+    """Extrahiert den gesamten Text aus einem PDF."""
+    doc = fitz.open(pdf_path)
+    text = ""
+    for page in doc:
+        text += page.get_text()
+    doc.close()
+    return text
+
+
+def _get_page_text(pdf_path: Path, page_num: int = 0) -> str:
+    """Extrahiert Text von einer bestimmten PDF-Seite."""
+    doc = fitz.open(pdf_path)
+    text = doc[page_num].get_text() if page_num < doc.page_count else ""
+    doc.close()
+    return text
+
+
+# ──────────────────────────────────────────────
+# End-to-End Tests
+# ──────────────────────────────────────────────
+
+class TestEndToEndFirstPerson:
+    """End-to-End: Reale Input-Datei + reales PDF-Template → nur erste Person."""
+
+    def test_input_file_exists(self):
+        """Stellt sicher, dass die reale Input-Datei vorhanden ist."""
+        assert INPUT_FILE.exists(), f"Input-Datei nicht gefunden: {INPUT_FILE}"
+
+    def test_template_file_exists(self):
+        """Stellt sicher, dass das reale PDF-Template vorhanden ist."""
+        assert TEMPLATE_FILE.exists(), f"PDF-Template nicht gefunden: {TEMPLATE_FILE}"
+
+    def test_template_has_field_markers(self, app_config):
+        """Stellt sicher, dass alle _Field-Platzhalter im PDF-Template vorhanden sind."""
+        doc = fitz.open(TEMPLATE_FILE)
+        missing = []
+        for m in app_config.output_mapping:
+            if m.pdf_field is None:
+                continue
+            # Suche auf allen Seiten
+            found_any = False
+            for page_num in range(doc.page_count):
+                if doc[page_num].search_for(m.pdf_field):
+                    found_any = True
+                    break
+            if not found_any:
+                missing.append(m.pdf_field)
+        doc.close()
+        assert len(missing) == 0, (
+            f"Folgende _Field-Platzhalter fehlen im PDF: {missing}"
+        )
+
+    def test_parse_real_input(self, parsed_records):
+        """Validiert das Parsen der realen Input-Datei."""
+        # Sollte 168 Einträge über 12 Monate für 19 Personen ergeben
+        assert len(parsed_records) == 168, (
+            f"Erwartet 168 Records, aber {len(parsed_records)} gefunden"
+        )
+
+        employees = get_unique_employees(parsed_records)
+        assert len(employees) == 19, (
+            f"Erwartet 19 Mitarbeiter, aber {len(employees)} gefunden"
+        )
+
+        # Erste Person alphabetisch: Draßdo, Cornelia
+        assert employees[0] == "Draßdo, Cornelia", (
+            f"Erwartet 'Draßdo, Cornelia' als erste Person, aber '{employees[0]}'"
+        )
+
+    def test_full_pipeline_first_person(
+        self, app_config, parsed_records, output_dir
+    ):
+        """Kompletter Workflow für die erste gefundene Person (Draßdo, Cornelia)."""
+        # 1. Nach Mitarbeiter gruppieren
+        grouped = group_by_employee(parsed_records)
+        assert len(grouped) == 19
+
+        # 2. Erste Person alphabetisch
+        first_person = sorted(grouped.keys())[0]
+        assert first_person == "Draßdo, Cornelia"
+
+        first_records = grouped[first_person]
+        # Draßdo hat 12 Einträge (einen pro Monat)
+        assert len(first_records) == 12, (
+            f"Erwartet 12 Records für {first_person}, aber {len(first_records)}"
+        )
+
+        # 3. Reports NUR für die erste Person generieren
+        single_person_group = {first_person: first_records}
+        generated = generate_activity_reports(
+            employee_records=single_person_group,
+            template_path=TEMPLATE_FILE,
+            mapping=app_config.output_mapping,
+            output_dir=output_dir,
+            filename_pattern=app_config.filename_pattern,
+        )
+
+        # 4. Ergebnisse prüfen
+        assert len(generated) == 1, (
+            f"Erwartet 1 generierte Datei, aber {len(generated)}"
+        )
+        output_file = generated[0]
+        assert output_file.exists(), f"Output-Datei nicht gefunden: {output_file}"
+        assert output_file.suffix == ".pdf"
+
+        erwarteter_name = "Draßdo_Cornelia_Tätigkeitsnachweis.pdf"
+        assert output_file.name == erwarteter_name, (
+            f"Erwartet '{erwarteter_name}', aber '{output_file.name}'"
+        )
+
+        # 5. PDF öffnen und Inhalt validieren
+        doc = fitz.open(output_file)
+        assert doc.page_count == 24, (
+            f"Erwartet 24 Seiten (12 Monate × 2 Seiten), aber {doc.page_count}"
+        )
+
+        # 6. Prüfe, dass KEINE _Field-Platzhalter mehr im Output sind
+        full_text = ""
+        for page in doc:
+            full_text += page.get_text()
+        assert "_Field" not in full_text, (
+            "Es sind noch _Field-Platzhalter im Output-PDF vorhanden!"
+        )
+
+        # 7. Prüfe Seite 0 (Januar, Seite 1 – Stammdaten)
+        jan0_text = doc[0].get_text()
+        assert "100740439" in jan0_text, "Antragsnummer fehlt auf Januar-Seite 1"
+        assert "Draßdo, Cornelia" in jan0_text, "Name fehlt auf Januar-Seite 1"
+        assert "50" in jan0_text, "Stellenanteil fehlt auf Januar-Seite 1"
+        assert "Meisterabschluß Küche" in jan0_text, "Qualifikation fehlt auf Januar-Seite 1"
+        assert "01.2025" in jan0_text, "Monat fehlt auf Januar-Seite 1"
+        assert "Anleiterin  / Ausbilderin" in jan0_text, "Funktion fehlt auf Januar-Seite 1"
+        assert "Tätigkeiten im Praxisbereich Garten" in jan0_text, "Tätigkeit fehlt auf Januar-Seite 1"
+
+        # 8. Prüfe Seite 1 (Januar, Seite 2 – Unterschriftsblock mit Ort/Datum)
+        jan1_text = doc[1].get_text()
+        assert "100740439" not in jan1_text, "Antragsnummer sollte nicht auf Seite 2 sein"
+        assert "Dresden" in jan1_text, "Ort 'Dresden' fehlt auf Januar-Seite 2"
+        assert "31.01.2025" in jan1_text, "Datum '31.01.2025' fehlt auf Januar-Seite 2"
+        # Tätigkeit wiederholt auf Seite 2
+        assert "Tätigkeiten im Praxisbereich Garten" in jan1_text, "Tätigkeit fehlt auf Januar-Seite 2"
+
+        # 9. Prüfe Juli (Seite 12+13) – Stellenanteil wechselt auf 40%
+        jul0_text = doc[12].get_text()
+        assert "40" in jul0_text, "Stellenanteil 40% fehlt auf Juli-Seite 1"
+        assert "07.2025" in jul0_text, "Monat 07.2025 fehlt auf Juli-Seite 1"
+
+        jul1_text = doc[13].get_text()
+        assert "31.07.2025" in jul1_text, "Datum 31.07.2025 fehlt auf Juli-Seite 2"
+
+        doc.close()