Abrechnungsgrüne nun immer erforderlich

Konflikte in den Steuer-Dateien zugunsten der weiterentwickelten lokalen Version
aufgelöst: vat_pricing_mode (Preismodus), DB-gestützte tax_exemption_reasons mit FK,
typisierte Request-DTOs, Event-Steuer-Snapshot. origin/dev-4.7.0 enthielt eine
frühere Teilmenge desselben Features.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.env.example

@@ -56,6 +56,8 @@ MAIL_PASSWORD=null
 MAIL_FROM_ADDRESS="hello@example.com"
 MAIL_FROM_NAME="${APP_NAME}"
 
+APP_ADMIN_MAIL=
+
 AWS_ACCESS_KEY_ID=
 AWS_SECRET_ACCESS_KEY=
 AWS_DEFAULT_REGION=us-east-1

.gitignore

@@ -23,3 +23,6 @@ Homestead.json
 Homestead.yaml
 Thumbs.db
 /docker-compose.yaml
+
+# HTML-Report von composer test:coverage
+/storage/coverage

CLAUDE.md

@@ -15,3 +15,60 @@ Routing, Mails) stehen in `.ai/conventions.md` und werden hier eingebunden — *
 
 - [Zahlungsmodule](app/EventPaymentModules/CLAUDE.md) — interface-gesteuerte Zahlungsarten (Optionen, Config,
   Anmelde-Zusammenfassung, GiroCode/Fähigkeits-Interfaces, neues Modul hinzufügen).
+
+## Umsatzsteuer / Steuerinformationen
+
+Rechtlich korrekter Begriff ist **Umsatzsteuer (USt)**, nicht MwSt. Ziel: tagesbasierte Anmelde-Rechnungen („Teilnahme
+Veranstaltung X in Gruppe Y" × Anwesenheitstage × Beitrag/Tag). Grundlage ist gebaut, die Rechnungs-PDF/-berechnung
+folgt noch.
+
+### Tenant-Einstellungen (Tab „Steuerinformationen")
+
+Felder auf `tenants` (Self-Service `TenantData.vue` + verwaltet `TenantEdit.vue`, Partial `TenantTaxInfo.vue`,
+Controller `TenantTax*` / `ManagedTenantTax*`, Action `UpdateTenantTax`):
+
+- `tax_liable` (bool) — ob USt-Pflicht besteht.
+- `vat_rate` (int, %) — USt-Satz, nur relevant wenn `tax_liable` (0–100, geclamped).
+- `vat_pricing_mode` (Enum `App\Enumerations\VatPricingMode`, natives PHP-Enum: `inclusive` | `add_on`).
+- `tax_exemption_reason` (FK → `tax_exemption_reasons.slug`, nullable) — Grund wenn **nicht** steuerpflichtig.
+  DB-Default neuer Tenants: `ustg_4_25a` (Jugendhilfe).
+- `tax_exemption_note` (text, nullable) — Freitext, nur bei Grund `custom` (`requires_note`).
+
+### Preismodus — **das Kernverhalten**
+
+Es wird **immer der finale Brutto-Beitrag** pro Anmeldung gespeichert (`EventParticipant.amount`, keine USt-Spalten am
+Teilnehmer). Der Modus wirkt **nur bei der Preisermittlung im Anmeldeprozess**:
+
+- **`inclusive`** (Brutto / „zusammenfassen", Supermarkt-Prinzip, Default): der konfigurierte Beitrag **ist** der
+  Endpreis, USt ist bereits enthalten → Preis bleibt gleich; die USt wird erst **auf der Rechnung herausgerechnet**:
+  `USt = brutto × Satz / (100 + Satz)`, `netto = brutto − USt`.
+- **`add_on`** (Netto / „aufaddieren"): der konfigurierte Beitrag ist netto → Endpreis = `Beitrag × (1 + Satz/100)`. Die
+  USt wird bei der Anmeldung **aufgeschlagen** → Teilnehmer zahlt mehr.
+
+Umsetzung in `App\Resources\EventResource::calculateAmount()`: nach allen Multiplikatoren (Early-Bird, `pay_per_day`,
+Geschwister) gilt
+`if ($event->tax_liable && $event->vat_pricing_mode === VatPricingMode::AddOn->value) $fee->multiply(1 + $event->vat_rate/100);`
+danach `round(…, 2)`. Bei `inclusive`/nicht steuerpflichtig bleibt der Beitrag unverändert.
+
+### Event-Snapshot (unveränderlich)
+
+Bei Event-Anlage (`CreateEventCommand::execute()`) werden `tax_liable`, `vat_rate`, `vat_pricing_mode`,
+`tax_exemption_reason`, `tax_exemption_note` aus dem Tenant **auf das Event kopiert und dort eingefroren** (Spalten auf
+`events`). Preisermittlung und spätere Rechnungen lesen vom Event, nicht vom Tenant → spätere Tenant-Änderungen berühren
+bestehende Events/Rechnungen nicht.
+
+### Befreiungsgründe (DB-gestützt)
+
+Tabelle `tax_exemption_reasons`, Model `App\Enumerations\TaxExemptionReason` (Eloquent, `slug` PK; `name`,
+`invoice_text`, `requires_note`, `sort_order`). `options()` liefert `{value,label,text}` sortiert nach `sort_order`. FK
+von `tenants` **und** `events`. Seed in Migration `170010`, verfeinert in `170020`. Gründe (in Reihenfolge):
+`ustg_19` (§ 19 Kleinunternehmer), `ustg_4_24` (§ 4 Nr. 24 Jugendherbergen),
+`ustg_4_25a` (§ 4 Nr. 25 Buchst. a — Jugendhilfe-Veranstaltungen, Default), `ustg_4_22a` (§ 4 Nr. 22 Buchst. a —
+Vorträge/Kurse), `custom` (Freitext). Jeder Grund kapselt den Rechnungs-Pflichthinweis nach **§ 14 Abs. 4 Nr. 8 UStG**
+(`invoice_text`; bei `custom` der Tenant-Freitext via `invoiceText(?note)`). Gemeinnützigkeit allein befreit **nicht** —
+es braucht immer einen konkreten Rechtsgrund.
+
+### Noch offen (nächster Schritt)
+
+Die eigentliche **Rechnung**: tagesbasierte Positionen, USt aus dem gespeicherten Brutto herausrechnen (Satz vom
+Event-Snapshot); bei Befreiung kein USt-Ausweis, stattdessen der Pflichthinweis des Grundes.

app/Domains/Admin/Actions/UpdateDocumentAsset/UpdateDocumentAssetAction.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentAsset;
+
+use App\Models\DocumentAsset;
+
+/**
+ * Legt ein Bild für die Dokumentvorlagen an oder ersetzt es.
+ *
+ * Gespeichert wird der base64-Payload in der Datenbank -- so überlebt das Bild ein Release (das als
+ * `git checkout` alles unter `public/` überschreibt) und wandert mit jedem Dump mit.
+ */
+class UpdateDocumentAssetAction
+{
+    /** Über 2 MB wird die Vorlage träge und das PDF unnötig groß. */
+    private const int MAX_BYTES = 2 * 1024 * 1024;
+
+    /** @var array<string, string> */
+    private const array ALLOWED_MIME_TYPES = [
+        'image/png' => 'png',
+        'image/jpeg' => 'jpg',
+        'image/gif' => 'gif',
+        'image/svg+xml' => 'svg',
+    ];
+
+    public function __construct(private readonly UpdateDocumentAssetRequest $request)
+    {
+    }
+
+    public function execute(): UpdateDocumentAssetResponse
+    {
+        $response = new UpdateDocumentAssetResponse();
+
+        $name = $this->normalizeName($this->request->name);
+
+        if ($name === null) {
+            $response->message = 'Bitte einen Namen aus Kleinbuchstaben, Ziffern, Bindestrich oder Unterstrich angeben.';
+
+            return $response;
+        }
+
+        $asset = DocumentAsset::where('name', $name)->first();
+        $file = $this->request->file;
+
+        if ($file === null && $asset === null) {
+            $response->message = 'Für ein neues Bild wird eine Datei benötigt.';
+
+            return $response;
+        }
+
+        $attributes = ['name' => $name, 'label' => $this->request->label];
+
+        if ($file !== null) {
+            if (!array_key_exists($file->getMimeType(), self::ALLOWED_MIME_TYPES)) {
+                $response->message = 'Nur PNG, JPEG, GIF oder SVG sind zulässig.';
+
+                return $response;
+            }
+
+            if ($file->getSize() > self::MAX_BYTES) {
+                $response->message = 'Das Bild darf höchstens 2 MB groß sein.';
+
+                return $response;
+            }
+
+            $attributes['mime'] = $file->getMimeType();
+            $attributes['data'] = base64_encode(file_get_contents($file->getRealPath()));
+        }
+
+        $response->asset = $asset === null
+            ? DocumentAsset::create($attributes)
+            : tap($asset)->update($attributes);
+
+        $response->success = true;
+        $response->message = 'Das Bild wurde gespeichert.';
+
+        return $response;
+    }
+
+    /** Namen sind Slugs, damit `{asset:name}` eindeutig erkennbar bleibt. */
+    private function normalizeName(string $name): ?string
+    {
+        $name = strtolower(trim($name));
+
+        return preg_match('/^[a-z0-9_-]+$/', $name) === 1 ? $name : null;
+    }
+}

app/Domains/Admin/Actions/UpdateDocumentAsset/UpdateDocumentAssetRequest.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentAsset;
+
+use Illuminate\Http\UploadedFile;
+
+class UpdateDocumentAssetRequest
+{
+    public function __construct(
+        /** Slug, unter dem das Bild in der Vorlage als `{asset:name}` referenziert wird. */
+        public readonly string $name,
+        public readonly ?string $label = null,
+        public readonly ?UploadedFile $file = null,
+    ) {
+    }
+}

app/Domains/Admin/Actions/UpdateDocumentAsset/UpdateDocumentAssetResponse.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentAsset;
+
+use App\Models\DocumentAsset;
+
+class UpdateDocumentAssetResponse
+{
+    public bool $success = false;
+
+    public ?string $message = null;
+
+    public ?DocumentAsset $asset = null;
+}

app/Domains/Admin/Actions/UpdateDocumentTemplate/UpdateDocumentTemplateAction.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentTemplate;
+
+use App\Models\DocumentTemplate;
+
+/**
+ * Speichert die Blockinhalte einer Dokumentvorlage.
+ *
+ * Es werden nur bereits angelegte, als editierbar markierte Blöcke geschrieben. Neue Blöcke entstehen
+ * nicht über das Formular -- welche Blöcke eine Dokumentart hat, gibt die Vorlage vor (das Layout
+ * verweist mit `{block:...}` auf sie).
+ */
+class UpdateDocumentTemplateAction
+{
+    public function __construct(private readonly UpdateDocumentTemplateRequest $request)
+    {
+    }
+
+    public function execute(): UpdateDocumentTemplateResponse
+    {
+        $response = new UpdateDocumentTemplateResponse();
+
+        $existing = DocumentTemplate::forType($this->request->documentType);
+
+        // Erst prüfen, dann schreiben -- sonst bliebe bei einem Fehler ein halb gespeicherter Stand übrig.
+        $rejection = $this->rejectBareAssetInStyle();
+        if ($rejection !== null) {
+            $response->message = $rejection;
+
+            return $response;
+        }
+
+        foreach ($this->request->blocks as $block => $content) {
+            $template = $existing->get($block);
+
+            if ($template === null || !$template->editable) {
+                $response->skipped[] = $block;
+                continue;
+            }
+
+            $template->update(['content' => (string) $content]);
+        }
+
+        $response->success = true;
+        $response->message = $response->skipped === []
+            ? 'Die Vorlage wurde gespeichert.'
+            : 'Die Vorlage wurde gespeichert; nicht editierbare Blöcke blieben unverändert.';
+
+        return $response;
+    }
+
+    /**
+     * Ein Bild-Platzhalter, der im CSS nicht in `url(...)` steht, expandiert zu einem Data-URI, das
+     * dompdf nicht auslagern kann -- der Parser läuft dann minutenlang und der FPM-Worker stirbt am
+     * Zeitlimit (502). Solches CSS wird gar nicht erst gespeichert.
+     *
+     * @return string|null Fehlermeldung, oder null wenn nichts zu beanstanden ist.
+     */
+    private function rejectBareAssetInStyle(): ?string
+    {
+        $style = $this->request->blocks[DocumentTemplate::BLOCK_STYLE] ?? null;
+
+        if ($style === null || preg_match('/(?<![("\'])\{asset:([a-z0-9_-]+)}/i', (string) $style, $match) !== 1) {
+            return null;
+        }
+
+        return sprintf(
+            'Im CSS-Block steht der Bild-Platzhalter {asset:%1$s} direkt im Text. Dort gehört er in url("{asset:%1$s}").',
+            $match[1]
+        );
+    }
+}

app/Domains/Admin/Actions/UpdateDocumentTemplate/UpdateDocumentTemplateRequest.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentTemplate;
+
+class UpdateDocumentTemplateRequest
+{
+    /**
+     * @param array<string, string> $blocks Blockinhalte, adressiert über den Block-Slug.
+     */
+    public function __construct(
+        public readonly string $documentType,
+        public readonly array $blocks,
+    ) {
+    }
+}

app/Domains/Admin/Actions/UpdateDocumentTemplate/UpdateDocumentTemplateResponse.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateDocumentTemplate;
+
+class UpdateDocumentTemplateResponse
+{
+    public bool $success = false;
+
+    public ?string $message = null;
+
+    /** @var array<int, string> Blöcke, die nicht gespeichert wurden (unbekannt oder nicht editierbar). */
+    public array $skipped = [];
+}

app/Domains/Admin/Actions/UpdateTenantContact/UpdateTenantContactAction.php

@@ -2,6 +2,8 @@
 
 namespace App\Domains\Admin\Actions\UpdateTenantContact;
 
+use App\Support\Text;
+
 class UpdateTenantContactAction
 {
     public function __construct(private UpdateTenantContactRequest $request)
@@ -15,8 +17,14 @@ class UpdateTenantContactAction
         $this->request->tenant->update([
             'email' => $this->request->email,
             'email_finance' => $this->request->emailFinance,
+            'invoice_sender_name' => Text::nullIfBlank($this->request->invoiceSenderName),
+            // Leergelassene optionale Felder als NULL, damit sie im Briefkopf sauber wegfallen.
+            'address_1' => Text::nullIfBlank($this->request->address1),
+            'address_2' => Text::nullIfBlank($this->request->address2),
+            'address_3' => Text::nullIfBlank($this->request->address3),
             'postcode' => $this->request->postcode,
             'city' => $this->request->city,
+            'phone' => Text::nullIfBlank($this->request->phone),
         ]);
 
         $response->success = true;

app/Domains/Admin/Actions/UpdateTenantContact/UpdateTenantContactRequest.php

@@ -12,6 +12,14 @@ class UpdateTenantContactRequest
         public string $emailFinance,
         public string $postcode,
         public string $city,
+        /** Bezeichnung des Rechnungsstellers; leer bedeutet "Name des Mandanten verwenden". */
+        public ?string $invoiceSenderName = null,
+        /** Straße und Hausnummer -- Pflichtangabe auf Rechnungen nach § 14 Abs. 4 UStG. */
+        public ?string $address1 = null,
+        /** Optionale Zusatzzeile, z.B. "c/o ...". */
+        public ?string $address2 = null,
+        public ?string $address3 = null,
+        public ?string $phone = null,
     ) {
     }
 }

app/Domains/Admin/Actions/UpdateTenantTax/UpdateTenantTaxAction.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateTenantTax;
+
+use App\Enumerations\VatPricingMode;
+use App\Models\Tenant;
+use App\Support\Text;
+
+class UpdateTenantTaxAction
+{
+    public function __construct(private UpdateTenantTaxRequest $request)
+    {
+    }
+
+    public function execute(): UpdateTenantTaxResponse
+    {
+        $response = new UpdateTenantTaxResponse();
+
+        // Präfixe sind großgeschrieben; null heißt "nicht mitgeschickt" und damit "unverändert".
+        $prefix = Text::nullIfBlank(strtoupper((string) $this->request->invoicePrefix));
+
+        if ($prefix !== null && $this->prefixTakenByAnotherTenant($prefix)) {
+            $response->message = sprintf('Das Rechnungs-Präfix "%s" wird bereits von einem anderen Mandanten genutzt.', $prefix);
+
+            return $response;
+        }
+
+        if ($this->request->taxLiable) {
+            $this->request->tenant->update($this->withInvoiceDetails([
+                'tax_liable' => true,
+                'vat_rate' => $this->clampVatRate($this->request->vatRate),
+                'vat_pricing_mode' => $this->request->vatPricingMode->value,
+                'tax_exemption_reason' => null,
+                'tax_exemption_note' => null,
+            ], $prefix));
+
+            $response->success = true;
+            $response->message = 'Steuerinformationen wurden gespeichert.';
+
+            return $response;
+        }
+
+        $reason = $this->request->exemptionReason;
+
+        if ($reason === null) {
+            $response->message = 'Bitte einen gültigen Befreiungsgrund auswählen.';
+
+            return $response;
+        }
+
+        $note = trim((string)$this->request->exemptionNote);
+
+        if ($reason->requires_note && $note === '') {
+            $response->message = 'Bitte einen Text für den Befreiungsgrund angeben.';
+
+            return $response;
+        }
+
+        $this->request->tenant->update($this->withInvoiceDetails([
+            'tax_liable' => false,
+            'vat_rate' => 0,
+            'vat_pricing_mode' => VatPricingMode::Inclusive->value,
+            'tax_exemption_reason' => $reason->slug,
+            'tax_exemption_note' => $reason->requires_note ? $note : null,
+        ], $prefix));
+
+        $response->success = true;
+        $response->message = 'Steuerinformationen wurden gespeichert.';
+
+        return $response;
+    }
+
+    private function clampVatRate(int $vatRate): int
+    {
+        return max(0, min(100, $vatRate));
+    }
+
+    /**
+     * Ergänzt die Rechnungsstellerangaben. Sie gelten unabhängig davon, ob Steuerpflicht besteht -- eine
+     * Steuernummer gehört auch auf eine steuerfreie Rechnung.
+     *
+     * @param array<string, mixed> $attributes
+     * @return array<string, mixed>
+     */
+    private function withInvoiceDetails(array $attributes, ?string $prefix): array
+    {
+        $attributes['tax_number'] = Text::nullIfBlank($this->request->taxNumber);
+        $attributes['vat_id'] = Text::nullIfBlank($this->request->vatId);
+
+        // Nicht mitgeschickt heißt "unverändert", nicht "leeren".
+        if ($prefix !== null) {
+            $attributes['invoice_prefix'] = $prefix;
+        }
+
+        return $attributes;
+    }
+
+    private function prefixTakenByAnotherTenant(string $prefix): bool
+    {
+        return Tenant::where('invoice_prefix', $prefix)
+            ->where('id', '!=', $this->request->tenant->id)
+            ->exists();
+    }
+}

app/Domains/Admin/Actions/UpdateTenantTax/UpdateTenantTaxRequest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateTenantTax;
+
+use App\Enumerations\TaxExemptionReason;
+use App\Enumerations\VatPricingMode;
+use App\Models\Tenant;
+
+class UpdateTenantTaxRequest
+{
+    public function __construct(
+        public Tenant $tenant,
+        public bool $taxLiable,
+        public int $vatRate,
+        public ?TaxExemptionReason $exemptionReason,
+        public ?string $exemptionNote,
+        public VatPricingMode $vatPricingMode,
+        /** Steuernummer bzw. USt-IdNr. -- Pflichtangabe auf Rechnungen (§ 14 Abs. 4 Nr. 2 UStG). */
+        public ?string $taxNumber = null,
+        public ?string $vatId = null,
+        /**
+         * Erster Block der Rechnungsnummer. `null` heißt "unverändert lassen" -- im Self-Service wird das
+         * Feld gar nicht erst mitgeschickt, damit ein bestehender Nummernkreis nicht bricht.
+         */
+        public ?string $invoicePrefix = null,
+    )
+    {
+    }
+}

app/Domains/Admin/Actions/UpdateTenantTax/UpdateTenantTaxResponse.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Domains\Admin\Actions\UpdateTenantTax;
+
+class UpdateTenantTaxResponse
+{
+    public bool $success = false;
+    public string $message = '';
+}

app/Domains/Admin/Controllers/DocumentAssetDeleteController.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Models\DocumentAsset;
+use App\Models\DocumentTemplate;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+
+class DocumentAssetDeleteController extends CommonController
+{
+    public function __invoke(string $name): JsonResponse
+    {
+        $asset = DocumentAsset::where('name', $name)->first();
+
+        // Durchweg 200 mit Status im Body -- wie die übrigen Admin-Endpunkte, damit der Grund im Frontend
+        // ankommt (der Ajax-Helfer verwirft den Body bei Fehler-Statuscodes).
+        if ($asset === null) {
+            return response()->json(['status' => 'error', 'message' => 'Das Bild existiert nicht.']);
+        }
+
+        // Ein noch referenziertes Bild zu löschen würde stillschweigend eine Lücke in jede künftige
+        // Rechnung reißen -- der Platzhalter löst dann zu einem Leerstring auf.
+        if ($this->isReferenced($asset->name)) {
+            return response()->json([
+                'status' => 'error',
+                'message' => sprintf('Das Bild wird noch als {asset:%s} in der Vorlage verwendet.', $asset->name),
+            ]);
+        }
+
+        $asset->delete();
+
+        return response()->json(['status' => 'success', 'message' => 'Das Bild wurde gelöscht.']);
+    }
+
+    private function isReferenced(string $name): bool
+    {
+        return DocumentTemplate::query()
+            ->where('content', 'like', '%{asset:' . $name . '}%')
+            ->exists();
+    }
+}

app/Domains/Admin/Controllers/DocumentAssetUpdateController.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Domains\Admin\Actions\UpdateDocumentAsset\UpdateDocumentAssetAction;
+use App\Domains\Admin\Actions\UpdateDocumentAsset\UpdateDocumentAssetRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DocumentAssetUpdateController extends CommonController
+{
+    public function __invoke(Request $request): JsonResponse
+    {
+        $action = new UpdateDocumentAssetAction(new UpdateDocumentAssetRequest(
+            name: (string) $request->input('name'),
+            label: $request->input('label'),
+            file: $request->file('file'),
+        ));
+
+        $response = $action->execute();
+
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+            'token' => $response->asset !== null ? '{asset:' . $response->asset->name . '}' : null,
+        ]);
+    }
+}

app/Domains/Admin/Controllers/DocumentTemplatesGetController.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Models\DocumentAsset;
+use App\Models\DocumentTemplate;
+use App\Models\DocumentTypeCatalog;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DocumentTemplatesGetController extends CommonController
+{
+    public function __invoke(Request $request): JsonResponse
+    {
+        $documentType = (string) $request->input('type', DocumentTypeCatalog::default());
+
+        if (!DocumentTypeCatalog::has($documentType)) {
+            abort(422, 'Unbekannte Dokumentart.');
+        }
+
+        $blocks = DocumentTemplate::forType($documentType)
+            ->values()
+            ->map(fn(DocumentTemplate $block): array => [
+                'block' => $block->block,
+                'label' => DocumentTypeCatalog::blockLabel($documentType, $block->block),
+                'content' => (string) $block->content,
+                'editable' => $block->editable,
+                'source' => in_array($block->block, DocumentTypeCatalog::SOURCE_BLOCKS, true),
+            ]);
+
+        return response()->json([
+            'documentType' => $documentType,
+            'documentTypes' => DocumentTypeCatalog::options(),
+            'blocks' => $blocks,
+            // Die Bilder gelten für alle Dokumentarten -- sie hängen nicht am Typ.
+            'assets' => DocumentAsset::orderBy('name')->get()->map(fn(DocumentAsset $asset): array => [
+                'name' => $asset->name,
+                'label' => $asset->label,
+                'mime' => $asset->mime,
+                'token' => '{asset:' . $asset->name . '}',
+                'preview' => $asset->toDataUri(),
+            ]),
+            'tokenGroups' => DocumentTypeCatalog::tokenGroups($documentType),
+        ]);
+    }
+}

app/Domains/Admin/Controllers/DocumentTemplatesPageController.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Providers\InertiaProvider;
+use App\Scopes\CommonController;
+use Inertia\Response;
+
+class DocumentTemplatesPageController extends CommonController
+{
+    public function __invoke(): Response
+    {
+        return new InertiaProvider('Admin/DocumentTemplates', [])->render();
+    }
+}

app/Domains/Admin/Controllers/DocumentTemplatesPreviewController.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Models\DocumentTypeCatalog;
+use App\Providers\DocumentTemplateRenderProvider;
+use App\Providers\PdfGenerateAndDownloadProvider;
+use App\Scopes\CommonController;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+
+/**
+ * Rendert die Vorlage mit Beispieldaten, ohne sie zu speichern -- damit niemand blind HTML editiert.
+ */
+class DocumentTemplatesPreviewController extends CommonController
+{
+    public function __invoke(Request $request): Response
+    {
+        $documentType = (string) $request->input('type', DocumentTypeCatalog::default());
+
+        if (!DocumentTypeCatalog::has($documentType)) {
+            abort(422, 'Unbekannte Dokumentart.');
+        }
+
+        $html = new DocumentTemplateRenderProvider(
+            $documentType,
+            (array) $request->input('blocks', []),
+        )->render(DocumentTypeCatalog::sampleTokens($documentType));
+
+        return response(PdfGenerateAndDownloadProvider::fromHtml($html, 'portrait'), 200, [
+            'Content-Type' => 'application/pdf',
+            'Content-Disposition' => 'inline; filename="vorschau.pdf"',
+        ]);
+    }
+}

app/Domains/Admin/Controllers/DocumentTemplatesUpdateController.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Domains\Admin\Actions\UpdateDocumentTemplate\UpdateDocumentTemplateAction;
+use App\Domains\Admin\Actions\UpdateDocumentTemplate\UpdateDocumentTemplateRequest;
+use App\Models\DocumentTypeCatalog;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class DocumentTemplatesUpdateController extends CommonController
+{
+    public function __invoke(Request $request): JsonResponse
+    {
+        $documentType = (string) $request->input('type', DocumentTypeCatalog::default());
+
+        // Die Dokumentart bestimmt, welche Zeilen geschrieben werden -- ungeprüft weitergereicht wäre
+        // sie ein Weg, in beliebige Vorlagen zu schreiben.
+        if (!DocumentTypeCatalog::has($documentType)) {
+            abort(422, 'Unbekannte Dokumentart.');
+        }
+
+        $action = new UpdateDocumentTemplateAction(new UpdateDocumentTemplateRequest(
+            documentType: $documentType,
+            blocks: (array) $request->input('blocks', []),
+        ));
+
+        $response = $action->execute();
+
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+        ]);
+    }
+}

app/Domains/Admin/Controllers/ManagedTenantContactGetController.php

@@ -15,6 +15,13 @@ class ManagedTenantContactGetController extends CommonController
         return response()->json([
             'email' => $tenant->email,
             'email_finance' => $tenant->email_finance,
+            'invoice_sender_name' => $tenant->invoice_sender_name,
+            // Als Platzhalter im Formular: so heisst der Absender, solange nichts eingetragen ist.
+            'name' => $tenant->name,
+            'phone' => $tenant->phone,
+            'address_1' => $tenant->address_1,
+            'address_2' => $tenant->address_2,
+            'address_3' => $tenant->address_3,
             'postcode' => $tenant->postcode,
             'city' => $tenant->city,
             'saveEndpoint' => '/api/v1/admin/tenants/' . $slug . '/contact',

app/Domains/Admin/Controllers/ManagedTenantContactUpdateController.php

@@ -20,6 +20,11 @@ class ManagedTenantContactUpdateController extends CommonController
             emailFinance: $request->input('email_finance'),
             postcode: $request->input('postcode'),
             city: $request->input('city'),
+            invoiceSenderName: $request->input('invoice_sender_name'),
+            address1: $request->input('address_1'),
+            address2: $request->input('address_2'),
+            address3: $request->input('address_3'),
+            phone: $request->input('phone'),
         ));
 
         $response = $action->execute();

app/Domains/Admin/Controllers/ManagedTenantTaxGetController.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Enumerations\TaxExemptionReason;
+use App\Enumerations\VatPricingMode;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ManagedTenantTaxGetController extends CommonController
+{
+    public function __invoke(string $slug, Request $request): JsonResponse
+    {
+        $tenant = $this->adminTenants->findBySlug($slug);
+
+        return response()->json([
+            'tax_liable' => $tenant->tax_liable,
+            'vat_rate' => $tenant->vat_rate,
+            'tax_exemption_reason' => $tenant->tax_exemption_reason,
+            'tax_exemption_note' => $tenant->tax_exemption_note,
+            'vat_pricing_mode' => $tenant->vat_pricing_mode,
+            'tax_number' => $tenant->tax_number,
+            'vat_id' => $tenant->vat_id,
+            'invoice_prefix' => $tenant->invoice_prefix,
+            // In der Mandanten-Verwaltung ist der Nummernkreis änderbar.
+            'can_edit_invoice_prefix' => true,
+            'exemption_reasons' => TaxExemptionReason::options(),
+            'pricing_modes' => VatPricingMode::options(),
+            'saveEndpoint' => '/api/v1/admin/tenants/' . $slug . '/tax',
+        ]);
+    }
+}

app/Domains/Admin/Controllers/ManagedTenantTaxUpdateController.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Domains\Admin\Actions\UpdateTenantTax\UpdateTenantTaxAction;
+use App\Domains\Admin\Actions\UpdateTenantTax\UpdateTenantTaxRequest;
+use App\Enumerations\TaxExemptionReason;
+use App\Enumerations\VatPricingMode;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ManagedTenantTaxUpdateController extends CommonController
+{
+    public function __invoke(string $slug, Request $request): JsonResponse
+    {
+        $tenant = $this->adminTenants->findBySlug($slug);
+
+        $action = new UpdateTenantTaxAction(new UpdateTenantTaxRequest(
+            tenant: $tenant,
+            taxLiable: $request->boolean('tax_liable'),
+            vatRate: (int)$request->input('vat_rate', 0),
+            exemptionReason: TaxExemptionReason::where('slug', $request->input('tax_exemption_reason'))->first(),
+            exemptionNote: $request->input('tax_exemption_note'),
+            vatPricingMode: VatPricingMode::tryFrom((string) $request->input('vat_pricing_mode', 'inclusive')) ?? VatPricingMode::Inclusive,
+            taxNumber: $request->input('tax_number'),
+            vatId: $request->input('vat_id'),
+            invoicePrefix: $request->input('invoice_prefix'),
+        ));
+
+        $response = $action->execute();
+
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+        ]);
+    }
+}

app/Domains/Admin/Controllers/TenantContactGetController.php

@@ -13,6 +13,13 @@ class TenantContactGetController extends CommonController
         return response()->json([
             'email' => $this->tenant->email,
             'email_finance' => $this->tenant->email_finance,
+            'invoice_sender_name' => $this->tenant->invoice_sender_name,
+            // Als Platzhalter im Formular: so heisst der Absender, solange nichts eingetragen ist.
+            'name' => $this->tenant->name,
+            'phone' => $this->tenant->phone,
+            'address_1' => $this->tenant->address_1,
+            'address_2' => $this->tenant->address_2,
+            'address_3' => $this->tenant->address_3,
             'postcode' => $this->tenant->postcode,
             'city' => $this->tenant->city,
             'saveEndpoint' => '/api/v1/admin/tenant/contact',

app/Domains/Admin/Controllers/TenantContactUpdateController.php

@@ -18,6 +18,11 @@ class TenantContactUpdateController extends CommonController
             emailFinance: $request->input('email_finance'),
             postcode: $request->input('postcode'),
             city: $request->input('city'),
+            invoiceSenderName: $request->input('invoice_sender_name'),
+            address1: $request->input('address_1'),
+            address2: $request->input('address_2'),
+            address3: $request->input('address_3'),
+            phone: $request->input('phone'),
         ));
 
         $response = $action->execute();

app/Domains/Admin/Controllers/TenantTaxGetController.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Enumerations\TaxExemptionReason;
+use App\Enumerations\VatPricingMode;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class TenantTaxGetController extends CommonController
+{
+    public function __invoke(Request $request): JsonResponse
+    {
+        return response()->json([
+            'tax_liable' => $this->tenant->tax_liable,
+            'vat_rate' => $this->tenant->vat_rate,
+            'tax_exemption_reason' => $this->tenant->tax_exemption_reason,
+            'tax_exemption_note' => $this->tenant->tax_exemption_note,
+            'vat_pricing_mode' => $this->tenant->vat_pricing_mode,
+            'tax_number' => $this->tenant->tax_number,
+            'vat_id' => $this->tenant->vat_id,
+            'invoice_prefix' => $this->tenant->invoice_prefix,
+            // Im Self-Service nicht änderbar: das Präfix bestimmt den Nummernkreis.
+            'can_edit_invoice_prefix' => false,
+            'exemption_reasons' => TaxExemptionReason::options(),
+            'pricing_modes' => VatPricingMode::options(),
+            'saveEndpoint' => '/api/v1/admin/tenant/tax',
+        ]);
+    }
+}

app/Domains/Admin/Controllers/TenantTaxUpdateController.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Domains\Admin\Controllers;
+
+use App\Domains\Admin\Actions\UpdateTenantTax\UpdateTenantTaxAction;
+use App\Domains\Admin\Actions\UpdateTenantTax\UpdateTenantTaxRequest;
+use App\Enumerations\TaxExemptionReason;
+use App\Enumerations\VatPricingMode;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class TenantTaxUpdateController extends CommonController
+{
+    public function __invoke(Request $request): JsonResponse
+    {
+        $action = new UpdateTenantTaxAction(new UpdateTenantTaxRequest(
+            tenant: $this->tenant,
+            taxLiable: $request->boolean('tax_liable'),
+            vatRate: (int)$request->input('vat_rate', 0),
+            exemptionReason: TaxExemptionReason::where('slug', $request->input('tax_exemption_reason'))->first(),
+            exemptionNote: $request->input('tax_exemption_note'),
+            vatPricingMode: VatPricingMode::tryFrom((string) $request->input('vat_pricing_mode', 'inclusive')) ?? VatPricingMode::Inclusive,
+            taxNumber: $request->input('tax_number'),
+            vatId: $request->input('vat_id'),
+            // invoice_prefix wird hier bewusst nicht durchgereicht -- der Nummernkreis ist nur in der
+            // Mandanten-Verwaltung änderbar.
+        ));
+
+        $response = $action->execute();
+
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+        ]);
+    }
+}

app/Domains/Admin/Routes/api.php

@@ -1,10 +1,10 @@
 <?php
 
-use App\Domains\Admin\Controllers\UserDetailGetController;
+use App\Domains\Admin\Controllers\DocumentAssetDeleteController;
-use App\Domains\Admin\Controllers\UserListApiController;
+use App\Domains\Admin\Controllers\DocumentAssetUpdateController;
-use App\Domains\Admin\Controllers\UserResetPasswordController;
+use App\Domains\Admin\Controllers\DocumentTemplatesGetController;
-use App\Domains\Admin\Controllers\UserToggleActiveController;
+use App\Domains\Admin\Controllers\DocumentTemplatesPreviewController;
-use App\Domains\Admin\Controllers\UserUpdateController;
+use App\Domains\Admin\Controllers\DocumentTemplatesUpdateController;
 use App\Domains\Admin\Controllers\ManagedTenantContactGetController;
 use App\Domains\Admin\Controllers\ManagedTenantContactUpdateController;
 use App\Domains\Admin\Controllers\ManagedTenantGdprGetController;
@@ -13,6 +13,8 @@ use App\Domains\Admin\Controllers\ManagedTenantImpressGetController;
 use App\Domains\Admin\Controllers\ManagedTenantImpressUpdateController;
 use App\Domains\Admin\Controllers\ManagedTenantPaymentGetController;
 use App\Domains\Admin\Controllers\ManagedTenantPaymentUpdateController;
+use App\Domains\Admin\Controllers\ManagedTenantTaxGetController;
+use App\Domains\Admin\Controllers\ManagedTenantTaxUpdateController;
 use App\Domains\Admin\Controllers\TenantContactGetController;
 use App\Domains\Admin\Controllers\TenantContactUpdateController;
 use App\Domains\Admin\Controllers\TenantCreateController;
@@ -24,12 +26,20 @@ use App\Domains\Admin\Controllers\TenantImpressGetController;
 use App\Domains\Admin\Controllers\TenantImpressUpdateController;
 use App\Domains\Admin\Controllers\TenantListApiController;
 use App\Domains\Admin\Controllers\TenantPaymentGetController;
-use App\Domains\Admin\Controllers\TenantPaymentUpdateController;
 use App\Domains\Admin\Controllers\TenantPaymentMethodsGetController;
 use App\Domains\Admin\Controllers\TenantPaymentMethodsUpdateController;
+use App\Domains\Admin\Controllers\TenantPaymentUpdateController;
+use App\Domains\Admin\Controllers\TenantTaxGetController;
+use App\Domains\Admin\Controllers\TenantTaxUpdateController;
+use App\Domains\Admin\Controllers\UserDetailGetController;
+use App\Domains\Admin\Controllers\UserListApiController;
+use App\Domains\Admin\Controllers\UserResetPasswordController;
+use App\Domains\Admin\Controllers\UserToggleActiveController;
+use App\Domains\Admin\Controllers\UserUpdateController;
 use App\Middleware\AdminRoleMiddleware;
 use App\Middleware\IdentifyTenant;
 use App\Middleware\LvOnlyMiddleware;
+use App\Middleware\MainAdminRoleMiddleware;
 use Illuminate\Support\Facades\Route;
 
 Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->group(function () {
@@ -44,6 +54,8 @@ Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->
         Route::post('/impress', TenantImpressUpdateController::class);
         Route::get('/gdpr', TenantGdprGetController::class);
         Route::post('/gdpr', TenantGdprUpdateController::class);
+        Route::get('/tax', TenantTaxGetController::class);
+        Route::post('/tax', TenantTaxUpdateController::class);
     });
 
     Route::prefix('api/v1/admin/users')->group(function () {
@@ -54,6 +66,18 @@ Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->
         Route::post('/{id}/reset-password', UserResetPasswordController::class);
     });
 
+    // Dokumentvorlagen gelten app-weit für alle Mandanten -- deshalb nur für Hauptadministrator*innen,
+    // AdminRoleMiddleware allein ließe auch Gruppenleitungen durch.
+    Route::middleware(MainAdminRoleMiddleware::class)->group(function () {
+        Route::prefix('api/v1/admin/document-templates')->group(function () {
+            Route::get('/', DocumentTemplatesGetController::class);
+            Route::post('/', DocumentTemplatesUpdateController::class);
+            Route::post('/preview', DocumentTemplatesPreviewController::class);
+            Route::post('/assets', DocumentAssetUpdateController::class);
+            Route::delete('/assets/{name}', DocumentAssetDeleteController::class);
+        });
+    });
+
     Route::middleware(LvOnlyMiddleware::class)->group(function () {
         Route::prefix('api/v1/admin/tenants')->group(function () {
             Route::get('/list', TenantListApiController::class);
@@ -69,6 +93,8 @@ Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->
                 Route::post('/impress', ManagedTenantImpressUpdateController::class);
                 Route::get('/gdpr', ManagedTenantGdprGetController::class);
                 Route::post('/gdpr', ManagedTenantGdprUpdateController::class);
+                Route::get('/tax', ManagedTenantTaxGetController::class);
+                Route::post('/tax', ManagedTenantTaxUpdateController::class);
             });
         });
     });

app/Domains/Admin/Routes/web.php

@@ -1,6 +1,7 @@
 <?php
 
 use App\Domains\Admin\Controllers\AdminDashboardController;
+use App\Domains\Admin\Controllers\DocumentTemplatesPageController;
 use App\Domains\Admin\Controllers\TenantEditPageController;
 use App\Domains\Admin\Controllers\TenantListPageController;
 use App\Domains\Admin\Controllers\TenantPageController;
@@ -8,6 +9,7 @@ use App\Domains\Admin\Controllers\UserListPageController;
 use App\Middleware\AdminRoleMiddleware;
 use App\Middleware\IdentifyTenant;
 use App\Middleware\LvOnlyMiddleware;
+use App\Middleware\MainAdminRoleMiddleware;
 use Illuminate\Support\Facades\Route;
 
 Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->group(function () {
@@ -16,6 +18,11 @@ Route::middleware([IdentifyTenant::class, 'auth', AdminRoleMiddleware::class])->
         Route::get('/tenant', TenantPageController::class);
         Route::get('/users', UserListPageController::class);
 
+        // App-weit gültige Dokumentvorlagen -- nur für Hauptadministrator*innen.
+        Route::middleware(MainAdminRoleMiddleware::class)->group(function () {
+            Route::get('/document-templates', DocumentTemplatesPageController::class);
+        });
+
         Route::middleware(LvOnlyMiddleware::class)->group(function () {
             Route::get('/tenants', TenantListPageController::class);
             Route::get('/tenants/{slug}', TenantEditPageController::class);

app/Domains/Admin/Views/DocumentTemplates.vue

@@ -0,0 +1,666 @@
+<script setup>
+import {computed, onMounted, ref} from 'vue'
+import {toast} from 'vue3-toastify'
+import AdminAppLayout from '../../../../resources/js/layouts/AdminAppLayout.vue'
+import ShadowedBox from '../../../Views/Components/ShadowedBox.vue'
+import TextEditor from '../../../Views/Components/TextEditor.vue'
+import {useAjax} from '../../../../resources/js/components/ajaxHandler.js'
+
+const {request} = useAjax()
+
+const blocks = ref([])
+const assets = ref([])
+const tokenGroups = ref({})
+
+// Die Vorlagen sind nach Dokumentart getrennt; der Umschalter lädt jeweils deren Blöcke neu.
+const documentType = ref(null)
+const documentTypes = ref([])
+
+const activeBlock = ref(null)
+const saving = ref(false)
+
+// Die Vorschau ist ein PDF, das aus den aktuellen -- auch ungespeicherten -- Blockinhalten entsteht.
+const previewUrl = ref(null)
+const previewLoading = ref(false)
+
+const newAsset = ref({name: '', label: '', file: null})
+const assetInput = ref(null)
+
+const current = computed(() => blocks.value.find(b => b.block === activeBlock.value) ?? null)
+
+/** Beim Blockwechsel die gemerkte Einfügemarke verwerfen -- sie gehört zum vorigen Text. */
+function selectBlock(block) {
+    activeBlock.value = block
+    caret.value = null
+}
+
+onMounted(load)
+
+async function load() {
+    const query = documentType.value ? '?type=' + encodeURIComponent(documentType.value) : ''
+    const data = await request('/api/v1/admin/document-templates' + query, {method: 'GET'})
+    if (!data) {
+        toast.error('Die Vorlage konnte nicht geladen werden.')
+        return
+    }
+
+    documentType.value = data.documentType
+    documentTypes.value = data.documentTypes ?? []
+    blocks.value = data.blocks ?? []
+    assets.value = data.assets ?? []
+    tokenGroups.value = data.tokenGroups ?? {}
+    activeBlock.value = blocks.value.find(b => b.editable)?.block ?? blocks.value[0]?.block ?? null
+
+    await refreshPreview()
+}
+
+/** Beim Wechsel der Dokumentart alles neu holen -- Blöcke und Platzhalter sind je Art andere. */
+async function selectDocumentType(type) {
+    if (type === documentType.value) return
+
+    documentType.value = type
+    caret.value = null
+    await load()
+}
+
+/** Nur editierbare Blöcke werden gesendet; der generierte Rechnungsinhalt bleibt unverändert. */
+function editableBlocks() {
+    return Object.fromEntries(
+        blocks.value.filter(b => b.editable).map(b => [b.block, b.content ?? ''])
+    )
+}
+
+async function save() {
+    saving.value = true
+
+    try {
+        const response = await request('/api/v1/admin/document-templates', {
+            method: 'POST',
+            body: {type: documentType.value, blocks: editableBlocks()},
+        })
+
+        if (response?.status === 'success') {
+            toast.success(response.message)
+        } else {
+            toast.error(response?.message ?? 'Fehler beim Speichern')
+        }
+    } finally {
+        saving.value = false
+    }
+}
+
+async function refreshPreview() {
+    previewLoading.value = true
+
+    try {
+        const response = await fetch('/api/v1/admin/document-templates/preview', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.content ?? '',
+            },
+            body: JSON.stringify({type: documentType.value, blocks: editableBlocks()}),
+        })
+
+        if (!response.ok) {
+            toast.error('Die Vorschau konnte nicht erzeugt werden.')
+            return
+        }
+
+        if (previewUrl.value) {
+            URL.revokeObjectURL(previewUrl.value)
+        }
+
+        previewUrl.value = URL.createObjectURL(await response.blob())
+    } finally {
+        previewLoading.value = false
+    }
+}
+
+/**
+ * Platzhalter an der Einfügemarke ergänzen. Im WYSIWYG-Editor übernimmt das TinyMCE selbst, im
+ * Quelltext-Editor wird an der zuletzt bekannten Cursorposition eingesetzt.
+ */
+function insertToken(token) {
+    const block = current.value
+    if (!block) return
+
+    const placeholder = wrapForBlock('{' + token + '}', token, block)
+
+    if (block.source) {
+        insertIntoTextarea(placeholder)
+        return
+    }
+
+    const editor = window.tinymce?.activeEditor
+    if (editor) {
+        editor.execCommand('mceInsertContent', false, placeholder)
+    } else {
+        block.content = (block.content ?? '') + placeholder
+    }
+}
+
+/**
+ * Ein Bild-Platzhalter allein ist nirgends sinnvoll: er expandiert zum nackten Data-URI, das dann als
+ * Zeichenkette im Dokument steht. Er braucht immer eine Hülle — im CSS url("..."), sonst ein <img>.
+ *
+ * Im CSS ist das zusätzlich eine Frage der Funktionsfähigkeit: ein Data-URI ausserhalb von url()
+ * kann dompdf nicht verarbeiten und läuft ins Zeitlimit.
+ */
+function wrapForBlock(placeholder, token, block) {
+    if (!token.startsWith('asset:')) {
+        return placeholder
+    }
+
+    return block.block === 'style'
+        ? `url("${placeholder}")`
+        : `<img src="${placeholder}" alt="" />`
+}
+
+const sourceArea = ref(null)
+// Zuletzt bekannte Einfügemarke im Quelltext-Feld. Ohne das würde ein Klick in der weit darunter
+// liegenden Platzhalter- oder Bilder-Liste an unvorhersehbarer Stelle einfügen.
+const caret = ref(null)
+
+function rememberCaret() {
+    const area = sourceArea.value
+    if (!area) return
+
+    caret.value = {start: area.selectionStart, end: area.selectionEnd}
+}
+
+function insertIntoTextarea(text) {
+    const block = current.value
+    if (!block) return
+
+    const content = block.content ?? ''
+    const position = caret.value
+
+    if (position === null) {
+        block.content = content + text
+        return
+    }
+
+    block.content = content.slice(0, position.start) + text + content.slice(position.end)
+    caret.value = {start: position.start + text.length, end: position.start + text.length}
+}
+
+async function uploadAsset() {
+    const form = new FormData()
+    form.append('name', newAsset.value.name)
+    form.append('label', newAsset.value.label ?? '')
+    if (newAsset.value.file) {
+        form.append('file', newAsset.value.file)
+    }
+
+    const result = await request('/api/v1/admin/document-templates/assets', {
+        method: 'POST',
+        body: form,
+    })
+
+    if (result?.status === 'success') {
+        toast.success(result.message)
+        newAsset.value = {name: '', label: '', file: null}
+        if (assetInput.value) assetInput.value.value = ''
+        await load()
+    } else {
+        toast.error(result?.message ?? 'Fehler beim Hochladen')
+    }
+}
+
+async function deleteAsset(name) {
+    if (!confirm(`Das Bild „${name}" wirklich löschen?`)) return
+
+    const result = await request('/api/v1/admin/document-templates/assets/' + name, {method: 'DELETE'})
+
+    if (result?.status === 'success') {
+        toast.success(result.message)
+        await load()
+    } else {
+        // Ein noch in der Vorlage referenziertes Bild lehnt der Server ab.
+        toast.error(result?.message ?? 'Das Bild konnte nicht gelöscht werden.')
+    }
+}
+
+function copyToken(token) {
+    navigator.clipboard?.writeText(token)
+    toast.success(`${token} kopiert`)
+}
+
+function onFileChosen(event) {
+    newAsset.value.file = event.target.files?.[0] ?? null
+}
+</script>
+
+<template>
+    <AdminAppLayout title="Dokumentvorlagen">
+        <shadowed-box style="width: 95%; margin: 20px auto; padding: 20px;">
+            <p class="intro">
+                Die Vorlagen gelten für <strong>alle Mandanten</strong>; die eingesetzten Werte kommen je
+                Dokument aus dem jeweiligen Mandanten. Sie liegen in der Datenbank und werden von einem
+                Update nicht überschrieben.
+            </p>
+
+            <div class="type-switch">
+                <label for="document-type">Dokumentart</label>
+                <select
+                    id="document-type"
+                    class="form-input"
+                    :value="documentType"
+                    @change="selectDocumentType($event.target.value)"
+                >
+                    <option v-for="type in documentTypes" :key="type.value" :value="type.value">
+                        {{ type.label }}
+                    </option>
+                </select>
+            </div>
+
+            <div class="layout">
+                <!-- ── Blöcke und Editor ── -->
+                <div class="editor-column">
+                    <div class="block-tabs">
+                        <button
+                            v-for="block in blocks"
+                            :key="block.block"
+                            class="block-tab"
+                            :class="{active: block.block === activeBlock, readonly: !block.editable}"
+                            @click="selectBlock(block.block)"
+                        >
+                            {{ block.label }}
+                            <span v-if="!block.editable" class="badge">generiert</span>
+                        </button>
+                    </div>
+
+                    <div v-if="current" class="editor-panel">
+                        <p v-if="!current.editable" class="notice">
+                            Dieser Block wird beim Erzeugen des Dokuments aus den Daten der Anmeldung
+                            zusammengesetzt und lässt sich nicht bearbeiten.
+                        </p>
+
+                        <p v-else-if="current.source" class="notice">
+                            Enthält den Seitenaufbau bzw. die Gestaltung und wird deshalb im Quelltext
+                            bearbeitet. Für Adresse, Logo oder Fußnote ist das nicht nötig.
+                        </p>
+
+                        <textarea
+                            v-if="current.source || !current.editable"
+                            ref="sourceArea"
+                            v-model="current.content"
+                            class="source-editor"
+                            :readonly="!current.editable"
+                            spellcheck="false"
+                            rows="24"
+                            @click="rememberCaret"
+                            @keyup="rememberCaret"
+                            @blur="rememberCaret"
+                        ></textarea>
+
+                        <!-- convert-urls aus: sonst schreibt TinyMCE {asset:...} in einem src um. -->
+                        <TextEditor v-else v-model="current.content" :convert-urls="false" />
+                    </div>
+
+                    <div class="actions">
+                        <button class="btn-save" :disabled="saving" @click="save">
+                            {{ saving ? 'Wird gespeichert…' : 'Speichern' }}
+                        </button>
+                        <button class="btn-secondary" :disabled="previewLoading" @click="refreshPreview">
+                            {{ previewLoading ? 'Wird erzeugt…' : 'Vorschau aktualisieren' }}
+                        </button>
+                    </div>
+
+                    <!-- ── Platzhalter ── -->
+                    <div class="tokens">
+                        <h3>Platzhalter</h3>
+                        <p class="tokens-hint">
+                            Klicken fügt den Platzhalter an der Einfügemarke ein — in
+                            <strong>{{ current?.label ?? '—' }}</strong>. Mit
+                            <code>{if:name}…{/if:name}</code> lässt sich ein Abschnitt weglassen, solange
+                            der Platzhalter leer ist.
+                        </p>
+
+                        <div v-for="(group, key) in tokenGroups" :key="key" class="token-group">
+                            <h4>{{ group.label }}</h4>
+                            <button
+                                v-for="(token, name) in group.tokens"
+                                :key="name"
+                                class="token"
+                                :title="token.description"
+                                @click="insertToken(name)"
+                            >{{ '{' + name + '}' }}</button>
+                        </div>
+                    </div>
+
+                    <!-- ── Bilder ── -->
+                    <div class="assets">
+                        <h3>Bilder</h3>
+                        <p class="tokens-hint">
+                            Liegen in der Datenbank, damit ein Update sie nicht überschreibt. „Einfügen"
+                            schreibt in <strong>{{ current?.label ?? '—' }}</strong><template
+                                v-if="current?.block === 'style'"> — im CSS als
+                            <code>url("…")</code>, anders kann dompdf ein Bild dort nicht verarbeiten</template>.
+                        </p>
+
+                        <table class="asset-table">
+                            <tr v-for="asset in assets" :key="asset.name">
+                                <td class="asset-preview"><img :src="asset.preview" :alt="asset.name" /></td>
+                                <td>
+                                    <strong>{{ asset.name }}</strong>
+                                    <span v-if="asset.label" class="asset-label">{{ asset.label }}</span>
+                                </td>
+                                <td>
+                                    <code class="token-code" @click="copyToken(asset.token)">{{ asset.token }}</code>
+                                </td>
+                                <td class="asset-actions">
+                                    <button class="btn-link" @click="insertToken('asset:' + asset.name)">Einfügen</button>
+                                    <button class="btn-link danger" @click="deleteAsset(asset.name)">Löschen</button>
+                                </td>
+                            </tr>
+                        </table>
+
+                        <div class="asset-upload">
+                            <input v-model="newAsset.name" type="text" placeholder="Name, z. B. logo" class="form-input" />
+                            <input v-model="newAsset.label" type="text" placeholder="Beschreibung (optional)" class="form-input" />
+                            <input ref="assetInput" type="file" accept="image/*" @change="onFileChosen" />
+                            <button class="btn-secondary" :disabled="!newAsset.name" @click="uploadAsset">
+                                Hochladen
+                            </button>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- ── Vorschau ── -->
+                <div class="preview-column">
+                    <h3>Vorschau</h3>
+                    <p class="tokens-hint">Mit Beispieldaten, ohne zu speichern.</p>
+                    <iframe v-if="previewUrl" :src="previewUrl" class="preview-frame"></iframe>
+                    <p v-else class="notice">Noch keine Vorschau erzeugt.</p>
+                </div>
+            </div>
+        </shadowed-box>
+    </AdminAppLayout>
+</template>
+
+<style scoped>
+.intro {
+    margin-bottom: 20px;
+    padding: 10px 12px;
+    border-left: 3px solid #f5c400;
+    background-color: #fffef5;
+    font-size: 0.9rem;
+    color: #4b5563;
+}
+
+.type-switch {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 18px;
+}
+
+.type-switch label {
+    font-weight: bold;
+    font-size: 0.9rem;
+    color: #4b5563;
+}
+
+.type-switch select {
+    width: auto;
+    min-width: 220px;
+}
+
+.layout {
+    display: flex;
+    gap: 24px;
+    align-items: flex-start;
+}
+
+.editor-column {
+    flex: 1 1 60%;
+    min-width: 0;
+}
+
+.preview-column {
+    flex: 1 1 40%;
+    min-width: 320px;
+    position: sticky;
+    top: 20px;
+}
+
+.block-tabs {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    margin-bottom: 12px;
+}
+
+.block-tab {
+    padding: 6px 12px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    background-color: #ffffff;
+    cursor: pointer;
+    font-size: 0.85rem;
+    color: #374151;
+}
+
+.block-tab.active {
+    background-color: #1d4899;
+    border-color: #1d4899;
+    color: #ffffff;
+}
+
+.block-tab.readonly {
+    color: #6b7280;
+}
+
+.badge {
+    margin-left: 6px;
+    padding: 1px 5px;
+    border-radius: 3px;
+    background-color: #e5e7eb;
+    color: #4b5563;
+    font-size: 0.7rem;
+}
+
+.block-tab.active .badge {
+    background-color: rgba(255, 255, 255, 0.25);
+    color: #ffffff;
+}
+
+.editor-panel {
+    margin-bottom: 12px;
+}
+
+.notice {
+    margin-bottom: 10px;
+    font-size: 0.85rem;
+    color: #6b7280;
+}
+
+.source-editor {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    font-family: 'DejaVu Sans Mono', Menlo, Consolas, monospace;
+    font-size: 0.82rem;
+    line-height: 1.5;
+    box-sizing: border-box;
+    resize: vertical;
+}
+
+.source-editor[readonly] {
+    background-color: #f9fafb;
+    color: #6b7280;
+}
+
+.actions {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 24px;
+}
+
+.btn-save, .btn-secondary {
+    padding: 8px 20px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-weight: bold;
+    font-size: 0.9rem;
+}
+
+.btn-save {
+    background-color: #16a34a;
+    color: #ffffff;
+}
+
+.btn-save:hover:not(:disabled) {
+    background-color: #15803d;
+}
+
+.btn-secondary {
+    background-color: #e5e7eb;
+    color: #374151;
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background-color: #d1d5db;
+}
+
+.btn-save:disabled, .btn-secondary:disabled {
+    opacity: 0.6;
+    cursor: default;
+}
+
+.tokens, .assets {
+    margin-bottom: 24px;
+}
+
+.tokens h3, .assets h3, .preview-column h3 {
+    margin-bottom: 6px;
+    font-size: 1rem;
+    color: #111827;
+}
+
+.tokens-hint {
+    margin-bottom: 10px;
+    font-size: 0.8rem;
+    color: #6b7280;
+}
+
+.tokens-hint code, .token-code {
+    padding: 1px 4px;
+    background-color: #f3f4f6;
+    border-radius: 3px;
+    font-size: 0.95em;
+}
+
+.token-group {
+    margin-bottom: 10px;
+}
+
+.token-group h4 {
+    margin-bottom: 4px;
+    font-size: 0.8rem;
+    font-weight: normal;
+    color: #6b7280;
+}
+
+.token {
+    margin: 0 4px 4px 0;
+    padding: 3px 8px;
+    border: 1px solid #d1d5db;
+    border-radius: 4px;
+    background-color: #f9fafb;
+    cursor: pointer;
+    font-family: 'DejaVu Sans Mono', Menlo, Consolas, monospace;
+    font-size: 0.75rem;
+    color: #374151;
+}
+
+.token:hover {
+    background-color: #eef2ff;
+    border-color: #1d4899;
+}
+
+.asset-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 12px;
+}
+
+.asset-table td {
+    padding: 6px 8px;
+    border-bottom: 1px solid #e5e7eb;
+    vertical-align: middle;
+    font-size: 0.85rem;
+}
+
+.asset-preview img {
+    max-width: 60px;
+    max-height: 40px;
+    display: block;
+}
+
+.asset-label {
+    display: block;
+    font-size: 0.75rem;
+    color: #6b7280;
+}
+
+.token-code {
+    cursor: pointer;
+    font-family: 'DejaVu Sans Mono', Menlo, Consolas, monospace;
+}
+
+.asset-actions {
+    text-align: right;
+    white-space: nowrap;
+}
+
+.btn-link {
+    padding: 2px 6px;
+    border: none;
+    background: none;
+    cursor: pointer;
+    font-size: 0.8rem;
+    color: #1d4899;
+}
+
+.btn-link.danger {
+    color: #b91c1c;
+}
+
+.asset-upload {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    align-items: center;
+}
+
+.form-input {
+    padding: 6px 10px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    font-size: 0.9rem;
+}
+
+.preview-frame {
+    width: 100%;
+    height: 780px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    background-color: #ffffff;
+}
+
+@media (max-width: 1100px) {
+    .layout {
+        flex-direction: column;
+    }
+
+    .preview-column {
+        position: static;
+        width: 100%;
+    }
+}
+</style>

app/Domains/Admin/Views/Partials/TenantContact.vue

@@ -13,9 +13,17 @@ const props = defineProps({
 const { request } = useAjax()
 
 const editing = ref(false)
+// Solange kein eigener Absender eingetragen ist, steht auf der Rechnung der Name des Mandanten.
+const senderFallback = props.data.name ?? ''
+
 const form = ref({
+    invoice_sender_name: props.data.invoice_sender_name ?? '',
     email: props.data.email ?? '',
     email_finance: props.data.email_finance ?? '',
+    phone: props.data.phone ?? '',
+    address_1: props.data.address_1 ?? '',
+    address_2: props.data.address_2 ?? '',
+    address_3: props.data.address_3 ?? '',
     postcode: props.data.postcode ?? '',
     city: props.data.city ?? '',
 })
@@ -39,16 +47,49 @@ async function save() {
 <template>
     <div v-if="!editing">
         <table class="data-table">
+            <tr>
+                <th>Rechnungs-Absender:</th>
+                <td>
+                    {{ form.invoice_sender_name || senderFallback }}
+                    <span v-if="!form.invoice_sender_name" class="field-hint">
+                        Name des Mandanten, da nichts Eigenes hinterlegt ist
+                    </span>
+                </td>
+            </tr>
             <tr><th>Email:</th><td>{{ form.email }}</td></tr>
             <tr><th>Email Schatzmeister*in:</th><td>{{ form.email_finance }}</td></tr>
+            <tr><th>Telefon:</th><td>{{ form.phone || '—' }}</td></tr>
+            <tr><th>Straße &amp; Hausnummer:</th><td>{{ form.address_1 || '—' }}</td></tr>
+            <tr><th>Adresszusatz:</th><td>{{ form.address_2 || '—' }}</td></tr>
+            <tr><th>Weiterer Zusatz:</th><td>{{ form.address_3 || '—' }}</td></tr>
             <tr><th>Postleitzahl:</th><td>{{ form.postcode }}</td></tr>
             <tr><th>Ort:</th><td>{{ form.city }}</td></tr>
         </table>
+
+        <p v-if="!form.address_1" class="hint">
+            Ohne Straße &amp; Hausnummer ist die Anschrift auf Rechnungen unvollständig
+            (§ 14 Abs. 4 UStG).
+        </p>
         <button class="btn-edit" @click="editing = true">Bearbeiten</button>
     </div>
 
     <div v-else>
         <table class="data-table">
+            <tr>
+                <th>Rechnungs-Absender:</th>
+                <td>
+                    <input
+                        type="text"
+                        v-model="form.invoice_sender_name"
+                        class="form-input"
+                        :placeholder="senderFallback"
+                    />
+                    <span class="field-hint">
+                        Vollständige Bezeichnung mit Rechtsform, wie sie auf der Rechnung stehen soll.
+                        Leer lassen, um den Namen des Mandanten zu verwenden.
+                    </span>
+                </td>
+            </tr>
             <tr>
                 <th>Email:</th>
                 <td><input type="email" v-model="form.email" class="form-input" /></td>
@@ -57,6 +98,27 @@ async function save() {
                 <th>Email Schatzmeister*in:</th>
                 <td><input type="email" v-model="form.email_finance" class="form-input" /></td>
             </tr>
+            <tr>
+                <th>Telefon:</th>
+                <td><input type="text" v-model="form.phone" class="form-input" /></td>
+            </tr>
+            <tr>
+                <th>Straße &amp; Hausnummer:</th>
+                <td>
+                    <input type="text" v-model="form.address_1" class="form-input" />
+                    <span class="field-hint">Pflichtangabe für Rechnungen (§ 14 Abs. 4 UStG)</span>
+                </td>
+            </tr>
+            <tr>
+                <th>Adresszusatz:</th>
+                <td>
+                    <input type="text" v-model="form.address_2" class="form-input" placeholder="z. B. c/o Mustermensch" />
+                </td>
+            </tr>
+            <tr>
+                <th>Weiterer Zusatz:</th>
+                <td><input type="text" v-model="form.address_3" class="form-input" /></td>
+            </tr>
             <tr>
                 <th>Postleitzahl:</th>
                 <td><input type="text" v-model="form.postcode" class="form-input" /></td>
@@ -101,6 +163,22 @@ async function save() {
     box-sizing: border-box;
 }
 
+.field-hint {
+    display: block;
+    margin-top: 4px;
+    font-size: 0.8rem;
+    color: #6b7280;
+}
+
+.hint {
+    margin-top: 12px;
+    padding: 10px 12px;
+    border-left: 3px solid #f5c400;
+    background-color: #fffef5;
+    font-size: 0.85rem;
+    color: #4b5563;
+}
+
 .btn-edit, .btn-save, .btn-cancel {
     margin-top: 15px;
     padding: 8px 20px;

app/Domains/Admin/Views/Partials/TenantTaxInfo.vue

@@ -0,0 +1,317 @@
+<script setup>
+import {computed, ref} from 'vue';
+import {useAjax} from "../../../../../resources/js/components/ajaxHandler.js";
+import RichSelectBox from "../../../../Views/Components/RichSelectBox.vue";
+import {toast} from "vue3-toastify";
+
+const props = defineProps({
+    data: {
+        type: Object,
+        default: () => ({})
+    },
+})
+
+const {request} = useAjax()
+
+const editing = ref(false)
+
+const reasons = computed(() => props.data.exemption_reasons ?? [])
+const pricingModes = computed(() => props.data.pricing_modes ?? [])
+
+const liableOptions = [
+    {value: '1', label: 'Ja – Umsatzsteuer wird erhoben'},
+    {value: '0', label: 'Nein – umsatzsteuerbefreit'},
+]
+
+const form = ref({
+    tax_liable: props.data.tax_liable ? '1' : '0',
+    vat_rate: props.data.vat_rate ?? 0,
+    tax_exemption_reason: props.data.tax_exemption_reason ?? '',
+    tax_exemption_note: props.data.tax_exemption_note ?? '',
+    vat_pricing_mode: props.data.vat_pricing_mode ?? 'inclusive',
+    tax_number: props.data.tax_number ?? '',
+    vat_id: props.data.vat_id ?? '',
+    invoice_prefix: props.data.invoice_prefix ?? '',
+})
+
+// Das Präfix bestimmt den Nummernkreis und darf sich nachträglich nicht ändern -- sonst gehörten bereits
+// herausgegebene Rechnungen plötzlich zu einer anderen Nummer. Nur in der verwalteten Ansicht editierbar.
+const canEditPrefix = computed(() => props.data.can_edit_invoice_prefix === true)
+
+const isLiable = computed(() => form.value.tax_liable === '1')
+const isCustomReason = computed(() => form.value.tax_exemption_reason === 'custom')
+
+const selectedReason = computed(
+    () => reasons.value.find(r => r.value === form.value.tax_exemption_reason) ?? null
+)
+
+const pricingModeLabel = computed(
+    () => pricingModes.value.find(m => m.value === form.value.vat_pricing_mode)?.label ?? '—'
+)
+
+// Vorschau des Pflichthinweises nach § 14 Abs. 4 Nr. 8 UStG, der später auf der Rechnung erscheint.
+const invoiceHint = computed(() => {
+    if (isLiable.value) {
+        return `Umsatzsteuerpflichtig – USt-Satz: ${form.value.vat_rate || 0} %`
+    }
+    if (isCustomReason.value) {
+        return form.value.tax_exemption_note?.trim() || '—'
+    }
+    return selectedReason.value?.text || '—'
+})
+
+const reasonLabel = computed(() => selectedReason.value?.label ?? '—')
+
+async function save() {
+    const saveUrl = props.data.saveEndpoint ?? '/api/v1/admin/tenant/tax'
+    const response = await request(saveUrl, {
+        method: 'POST',
+        body: {
+            tax_liable: isLiable.value,
+            vat_rate: Number(form.value.vat_rate) || 0,
+            tax_exemption_reason: isLiable.value ? null : form.value.tax_exemption_reason,
+            tax_exemption_note: form.value.tax_exemption_note,
+            vat_pricing_mode: form.value.vat_pricing_mode,
+            tax_number: form.value.tax_number,
+            vat_id: form.value.vat_id,
+            invoice_prefix: canEditPrefix.value ? form.value.invoice_prefix : undefined,
+        },
+    })
+
+    if (response && response.status === 'success') {
+        toast.success(response.message)
+        editing.value = false
+    } else {
+        toast.error(response?.message ?? 'Fehler beim Speichern')
+    }
+}
+</script>
+
+<template>
+    <div v-if="!editing">
+        <table class="data-table">
+            <tr>
+                <th>Steuerpflicht</th>
+                <td>{{ isLiable ? 'Ja – Umsatzsteuer wird erhoben' : 'Nein – umsatzsteuerbefreit' }}</td>
+            </tr>
+            <tr v-if="isLiable">
+                <th>USt-Satz</th>
+                <td>{{ form.vat_rate || 0 }} %</td>
+            </tr>
+            <tr v-if="isLiable">
+                <th>Preismodus</th>
+                <td>{{ pricingModeLabel }}</td>
+            </tr>
+            <tr v-else>
+                <th>Befreiungsgrund</th>
+                <td>{{ reasonLabel }}</td>
+            </tr>
+            <tr>
+                <th>Rechnungshinweis</th>
+                <td>{{ invoiceHint }}</td>
+            </tr>
+            <tr>
+                <th>Steuernummer</th>
+                <td>{{ form.tax_number || '—' }}</td>
+            </tr>
+            <tr>
+                <th>USt-IdNr.</th>
+                <td>{{ form.vat_id || '—' }}</td>
+            </tr>
+            <tr>
+                <th>Rechnungs-Präfix</th>
+                <td>{{ form.invoice_prefix || '—' }}</td>
+            </tr>
+        </table>
+        <button class="btn-edit" @click="editing = true">Bearbeiten</button>
+    </div>
+
+    <div v-else>
+        <table class="data-table">
+            <tr>
+                <th>Steuerpflicht</th>
+                <td>
+                    <RichSelectBox v-model="form.tax_liable" :options="liableOptions"/>
+                </td>
+            </tr>
+
+            <tr v-if="isLiable">
+                <th>USt-Satz (%)</th>
+                <td><input type="number" min="0" max="100" v-model.number="form.vat_rate" class="form-input"/></td>
+            </tr>
+            <tr v-if="isLiable">
+                <th>Preismodus</th>
+                <td>
+                    <RichSelectBox v-model="form.vat_pricing_mode" :options="pricingModes"/>
+                </td>
+            </tr>
+
+            <template v-else>
+                <tr>
+                    <th>Befreiungsgrund</th>
+                    <td>
+                        <RichSelectBox
+                            v-model="form.tax_exemption_reason"
+                            :options="reasons"
+                            placeholder="Grund auswählen…"
+                        />
+                    </td>
+                </tr>
+                <tr v-if="isCustomReason">
+                    <th>Freitext</th>
+                    <td>
+                        <textarea
+                            v-model="form.tax_exemption_note"
+                            class="form-input"
+                            rows="3"
+                            placeholder="Hinweistext für die Rechnung…"
+                        ></textarea>
+                    </td>
+                </tr>
+            </template>
+
+            <tr>
+                <th>Rechnungshinweis</th>
+                <td class="hint-preview">{{ invoiceHint }}</td>
+            </tr>
+
+            <tr>
+                <th>Steuernummer</th>
+                <td>
+                    <input type="text" v-model="form.tax_number" class="form-input" />
+                    <span class="field-hint">
+                        Pflichtangabe auf Rechnungen — alternativ die USt-IdNr. (§ 14 Abs. 4 Nr. 2 UStG)
+                    </span>
+                </td>
+            </tr>
+            <tr>
+                <th>USt-IdNr.</th>
+                <td><input type="text" v-model="form.vat_id" class="form-input" /></td>
+            </tr>
+            <tr>
+                <th>Rechnungs-Präfix</th>
+                <td>
+                    <input
+                        type="text"
+                        v-model="form.invoice_prefix"
+                        class="form-input"
+                        :disabled="!canEditPrefix"
+                    />
+                    <span class="field-hint">
+                        Erster Block der Rechnungsnummer, z. B. <code>WM</code> in
+                        <code>WM-V-20260701-0005</code>.
+                        <template v-if="canEditPrefix">
+                            Eine Änderung wirkt nur auf künftige Veranstaltungen; bereits angelegte behalten
+                            ihre Nummer.
+                        </template>
+                        <template v-else>
+                            Änderbar nur in der Mandanten-Verwaltung.
+                        </template>
+                    </span>
+                </td>
+            </tr>
+        </table>
+        <div class="btn-group">
+            <button class="btn-save" @click="save">Speichern</button>
+            <button class="btn-cancel" @click="editing = false">Abbrechen</button>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.data-table th {
+    text-align: left;
+    padding: 8px 12px;
+    width: 200px;
+    color: #374151;
+    border-bottom: 1px solid #e5e7eb;
+    vertical-align: top;
+}
+
+.data-table td {
+    padding: 8px 12px;
+    border-bottom: 1px solid #e5e7eb;
+}
+
+.form-input {
+    width: 100%;
+    padding: 6px 10px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    font-size: 0.95rem;
+    box-sizing: border-box;
+    font-family: inherit;
+}
+
+.hint-preview {
+    color: #6b7280;
+    font-style: italic;
+}
+
+.field-hint {
+    display: block;
+    margin-top: 4px;
+    font-size: 0.8rem;
+    color: #6b7280;
+}
+
+.field-hint code {
+    padding: 1px 4px;
+    background-color: #f3f4f6;
+    border-radius: 3px;
+    font-size: 0.95em;
+}
+
+.form-input:disabled {
+    background-color: #f3f4f6;
+    color: #6b7280;
+}
+
+.btn-edit, .btn-save, .btn-cancel {
+    margin-top: 15px;
+    padding: 8px 20px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-weight: bold;
+    font-size: 0.9rem;
+}
+
+.btn-edit {
+    background-color: #1d4899;
+    color: #ffffff;
+}
+
+.btn-edit:hover {
+    background-color: #163a7a;
+}
+
+.btn-save {
+    background-color: #16a34a;
+    color: #ffffff;
+}
+
+.btn-save:hover {
+    background-color: #15803d;
+}
+
+.btn-cancel {
+    background-color: #e5e7eb;
+    color: #374151;
+    margin-left: 10px;
+}
+
+.btn-cancel:hover {
+    background-color: #d1d5db;
+}
+
+.btn-group {
+    display: flex;
+    gap: 10px;
+}
+</style>

app/Domains/Admin/Views/TenantData.vue

@@ -7,6 +7,7 @@ import TenantPayment from "./Partials/TenantPayment.vue";
 import TenantImpress from "./Partials/TenantImpress.vue";
 import TenantGdpr from "./Partials/TenantGdpr.vue";
 import TenantPaymentMethods from "./Partials/TenantPaymentMethods.vue";
+import TenantTaxInfo from "./Partials/TenantTaxInfo.vue";
 
 const props = defineProps({
     tenant: Object,
@@ -28,6 +29,11 @@ const tabs = [
         component: TenantPaymentMethods,
         endpoint: '/api/v1/admin/tenant/payment-methods',
     },
+    {
+        title: 'Steuerinformationen',
+        component: TenantTaxInfo,
+        endpoint: '/api/v1/admin/tenant/tax',
+    },
     {
         title: 'Impressum',
         component: TenantImpress,

app/Domains/Admin/Views/TenantEdit.vue

@@ -7,6 +7,7 @@ import TenantContact from "./Partials/TenantContact.vue";
 import TenantPayment from "./Partials/TenantPayment.vue";
 import TenantImpress from "./Partials/TenantImpress.vue";
 import TenantGdpr from "./Partials/TenantGdpr.vue";
+import TenantTaxInfo from "./Partials/TenantTaxInfo.vue";
 
 const props = defineProps({
     tenant: Object,
@@ -30,6 +31,11 @@ const tabs = [
         component: TenantPayment,
         endpoint: '/api/v1/admin/tenants/' + slug + '/payment',
     },
+    {
+        title: 'Steuerinformationen',
+        component: TenantTaxInfo,
+        endpoint: '/api/v1/admin/tenants/' + slug + '/tax',
+    },
     {
         title: 'Impressum',
         component: TenantImpress,

app/Domains/CostUnit/Routes/web.php

@@ -2,11 +2,6 @@
 use App\Domains\CostUnit\Controllers\CreateController;
 use App\Domains\CostUnit\Controllers\ListController;
 use App\Domains\CostUnit\Controllers\OpenController;
-use App\Domains\UserManagement\Controllers\EmailVerificationController;
-use App\Domains\UserManagement\Controllers\LoginController;
-use App\Domains\UserManagement\Controllers\LogOutController;
-use App\Domains\UserManagement\Controllers\RegistrationController;
-use App\Domains\UserManagement\Controllers\ResetPasswordController;
 use App\Middleware\IdentifyTenant;
 use Illuminate\Support\Facades\Route;
 
@@ -23,16 +18,10 @@ Route::middleware(IdentifyTenant::class)->group(function () {
 
 
     });
-    Route::get('/register', [RegistrationController::class, 'loginForm']);
-    Route::get('/register/verifyEmail', [EmailVerificationController::class, 'verifyEmailForm']);
-
-    Route::get('/reset-password', [ResetPasswordController::class, 'resetPasswordForm']);
-
-    route::get('/logout', LogOutController::class);
-    route::post('/login', [LoginController::class, 'doLogin']);
-    route::get('/login', [LoginController::class, 'loginForm']);
-
 
+    // Anmeldung, Registrierung und Passwort-Reset gehören zur Domain UserManagement und sind dort
+    // definiert. Die Duplikate hier überschrieben die dortigen Routen -- unter anderem die benannte
+    // Route `login`, auf die Laravels `auth`-Middleware Gäste umleitet.
 });
 
 

app/Domains/Event/Actions/CreateEvent/CreateEventCommand.php

@@ -9,6 +9,7 @@ use App\Models\Tenant;
 use App\RelationModels\EventEatingHabits;
 use App\RelationModels\EventLocalGroups;
 use App\RelationModels\EventPaymentMethods;
+use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Str;
 
 class CreateEventCommand {
@@ -27,8 +28,13 @@ class CreateEventCommand {
         }
 
 
+        $tenant = app('tenant');
+
+        // Anlage als Ganzes: der Event-Teil der Rechnungsnummer wird unter der Sperre vergeben und muss
+        // im selben Zug geschrieben werden, sonst könnten zwei gleichzeitige Anlagen denselben erhalten.
+        $event = DB::transaction(function () use ($tenant): Event {
             $event = Event::create([
-            'tenant' => app('tenant')->slug,
+            'tenant' => $tenant->slug,
             'name' => $this->request->name,
             'identifier' => Str::random(10),
             'location' => $this->request->location,
@@ -47,8 +53,25 @@ class CreateEventCommand {
             'total_max_amount' => 0,
             'support_per_person' => 0,
             'support_flat' => 0,
+            // Umsatzsteuerliche Grundlage bei Anlage einfrieren (unveränderlich), damit Preisermittlung und
+            // spätere Rechnungen von späteren Tenant-Änderungen unberührt bleiben.
+            'tax_liable' => $tenant->tax_liable,
+            'vat_rate' => $tenant->vat_rate,
+            'vat_pricing_mode' => $tenant->vat_pricing_mode,
+            'tax_exemption_reason' => $tenant->tax_exemption_reason,
+            'tax_exemption_note' => $tenant->tax_exemption_note,
+            // Den Event-Teil der Rechnungsnummer einfrieren: Tenant-Präfix und Startdatum sind später
+            // änderbar, eine herausgegebene Rechnung würde sonst zu einer anderen Nummer gehören.
+            //
+            // Der Rechnungssteller wird bewusst NICHT mitkopiert -- er ist der Mandant und wird beim
+            // Erzeugen der Rechnung von dort gelesen, damit eine Korrektur an Name oder Anschrift auch
+            // auf bestehende Veranstaltungen wirkt.
+            'invoice_key' => $this->nextInvoiceKey($tenant),
             ]);
 
+            return $event;
+        });
+
         if ($event !== null) {
             EventEatingHabits::create([
                 'event_id' => $event->id,
@@ -83,4 +106,35 @@ class CreateEventCommand {
 
         return $response;
     }
+
+    /**
+     * Event-Teil der Rechnungsnummer, z.B. `WM-V-20260701`: Tenant-Präfix, Dokumentart „V" für
+     * Veranstaltung, dann ohne Trenner Jahr, Monat des Beginns und die laufende Nummer der
+     * Veranstaltungen dieses Tenants in diesem Monat.
+     *
+     * Gezählt wird über die bereits vergebenen Schlüssel desselben Monats. Die Sperre auf der
+     * Tenant-Zeile serialisiert gleichzeitige Anlagen; der Aufruf erfolgt innerhalb der
+     * Anlage-Transaktion, sodass die Sperre bis zum Schreiben des Events steht.
+     */
+    private function nextInvoiceKey(Tenant $tenant): string
+    {
+        // Jahr und Monat ohne Trenner; die laufende Nummer haengt unmittelbar daran. Alle drei Teile
+        // haben feste Laenge, der Schluessel bleibt dadurch eindeutig zerlegbar.
+        $month = $this->request->begin->format('Ym');
+        $prefix = sprintf('%s-V-%s', $tenant->invoice_prefix ?? strtoupper($tenant->slug), $month);
+
+        DB::table('tenants')->where('id', $tenant->id)->lockForUpdate()->first();
+
+        $used = DB::table('events')
+            ->where('tenant', $tenant->slug)
+            ->where('invoice_key', 'like', $prefix . '%')
+            ->pluck('invoice_key');
+
+        $highest = 0;
+        foreach ($used as $key) {
+            $highest = max($highest, (int) substr((string) $key, strlen($prefix)));
+        }
+
+        return $prefix . str_pad((string) ($highest + 1), 2, '0', STR_PAD_LEFT);
+    }
 }

app/Domains/Event/Actions/CreateIncomeSurplusStatement/CreateIncomeSurplusStatementCommand.php

@@ -0,0 +1,224 @@
+<?php
+
+namespace App\Domains\Event\Actions\CreateIncomeSurplusStatement;
+
+use App\Enumerations\ParticipationType;
+use App\Models\CostUnit;
+use App\Models\Event;
+use App\Providers\PdfGenerateAndDownloadProvider;
+use App\Repositories\CostUnitRepository;
+use App\ValueObjects\Amount;
+use Illuminate\Http\Request;
+
+/**
+ * Erzeugt die Einnahmen-Überschuss-Rechnung einer Veranstaltung als PDF.
+ *
+ * Gezeigt wird ausschließlich Geld, das geflossen ist: gezahlte Beiträge, weitere Einnahmen, was von
+ * Abmeldungen einbehalten wurde, Fördermittel -- und auf der anderen Seite die erfassten Belege. Was nur
+ * erwartet (offene Beiträge) oder geplant (Budgetwerte) ist, gehört in eine Einnahmen-Überschuss-Rechnung
+ * nicht hinein.
+ *
+ * Es wird nichts gespeichert: Alle Zahlen leiten sich aus dem aktuellen Stand ab, ein erneuter Abruf
+ * liefert den dann gültigen Stand.
+ */
+class CreateIncomeSurplusStatementCommand
+{
+    private Event $event;
+
+    private CostUnitRepository $costUnits;
+
+    public function __construct(private readonly CreateIncomeSurplusStatementRequest $request)
+    {
+        $this->event = $request->event;
+        $this->costUnits = new CostUnitRepository();
+    }
+
+    public function execute(): CreateIncomeSurplusStatementResponse
+    {
+        $response = new CreateIncomeSurplusStatementResponse();
+
+        $costUnit = $this->event->costUnit()->first();
+
+        if (!$costUnit instanceof CostUnit) {
+            $response->message = 'Der Veranstaltung ist keine Kostenstelle zugeordnet.';
+
+            return $response;
+        }
+
+        // Der Pauschalbetrag wird vor dem Resource-Aufruf gelesen: `EventResource::calculateSupportPerPerson()`
+        // multipliziert das Amount-Objekt von `support_per_person` in place. Auf `support_flat` wirkt das
+        // zwar nicht, aber der gesamte Zugriff auf Beträge des Models ist danach nicht mehr vertrauenswürdig.
+        $otherIncome = $this->event->support_flat->getAmount();
+
+        $eventData = $this->event->toResource()->toArray(new Request());
+
+        $income = $this->buildIncome($eventData, $otherIncome);
+        $expenses = $this->buildExpenses($costUnit);
+
+        $result = new Amount($income['total']->getAmount() - $expenses['total']->getAmount(), 'Euro');
+
+        $html = view('pdfs.income-surplus-statement', [
+            'event' => $this->event,
+            'createdAt' => new \DateTime()->format('d.m.Y'),
+            'income' => $income,
+            'expenses' => $expenses,
+            'result' => $result,
+            'money' => self::money(...),
+        ])->render();
+
+        $response->success = true;
+        $response->filename = 'EUER-' . $this->event->identifier . '.pdf';
+        $response->income = $income;
+        $response->expenses = $expenses;
+        $response->result = $result;
+        $response->pdfContent = PdfGenerateAndDownloadProvider::fromHtml($html, 'portrait');
+
+        return $response;
+    }
+
+    /**
+     * Die Einnahmenseite in zwei Ober-Kategorien.
+     *
+     * Alle Zahlen stammen aus {@see \App\Resources\EventResource} -- derselben Quelle wie die
+     * Veranstaltungsübersicht am Bildschirm. Eine eigene Rechnung daneben würde über kurz oder lang von
+     * der Übersicht abweichen, und dann glaubt niemand mehr einer der beiden Zahlen.
+     *
+     * @param array<string, mixed> $eventData
+     *
+     * @return array{categories: array<int, array{name: string, total: Amount, entries: array<int, array{name: string, amount: Amount}>}>, total: Amount}
+     */
+    private function buildIncome(array $eventData, float $otherIncome): array
+    {
+        // Beiträge aller Teilnahmearten in einer Zeile: Für die Mittelverwendung zählt, was an Beiträgen
+        // hereingekommen ist, nicht von wem.
+        $participationFees = new Amount(0, 'Euro');
+        foreach ([
+            ParticipationType::PARTICIPATION_TYPE_PARTICIPANT,
+            ParticipationType::PARTICIPATION_TYPE_TEAM,
+            ParticipationType::PARTICIPATION_TYPE_VOLUNTEER,
+            ParticipationType::PARTICIPATION_TYPE_OTHER,
+        ] as $participationType) {
+            $participationFees->addAmount(
+                new Amount((float) $eventData['participants'][$participationType]['amount']['paid']['value'], 'Euro')
+            );
+        }
+
+        $ownFunds = [
+            ['name' => 'Teilnahmebeiträge', 'amount' => $participationFees],
+            ['name' => 'Weitere Einnahmen', 'amount' => new Amount($otherIncome, 'Euro')],
+            [
+                'name' => 'Einbehaltene Einnahmen aus Abmeldungen',
+                'amount' => new Amount((float) $eventData['retainedFromUnregistered']['value'], 'Euro'),
+            ],
+        ];
+
+        $supportRate = new Amount((float) $eventData['supportPersonValue'], 'Euro');
+        $funding = [
+            [
+                'name' => 'Fördermittel (' . self::money($supportRate) . ' € p.P./Tag)',
+                'amount' => new Amount($eventData['supportPerson']['amount']->getAmount(), 'Euro'),
+            ],
+        ];
+
+        $categories = [
+            ['name' => 'Eigenmittel', 'entries' => $ownFunds, 'total' => self::sum($ownFunds)],
+            ['name' => 'Förderungen', 'entries' => $funding, 'total' => self::sum($funding)],
+        ];
+
+        return [
+            'categories' => $categories,
+            'total' => self::sum($categories),
+        ];
+    }
+
+    /**
+     * Die Ausgabenseite: eine Zeile je Ausgabentyp, dazu die Belege für die Anlage.
+     *
+     * @return array{groups: array<int, array{name: string, sum: Amount, rows: array<int, array{number: string, date: string, purpose: string, amount: Amount}>}>, total: Amount}
+     */
+    private function buildExpenses(CostUnit $costUnit): array
+    {
+        $groups = [];
+        $total = new Amount(0, 'Euro');
+
+        foreach ($this->costUnits->groupExpensesByType($costUnit) as $group) {
+            $rows = [];
+
+            foreach ($group['invoices'] as $invoice) {
+                $rows[] = [
+                    'number' => (string) $invoice->invoice_number,
+                    'date' => $invoice->created_at?->format('d.m.Y') ?? '',
+                    'purpose' => $this->purpose($invoice->type_other, $invoice->comment),
+                    'amount' => Amount::fromString($invoice->amount),
+                ];
+            }
+
+            $groups[] = [
+                'name' => $group['type']->name,
+                'sum' => $group['sum'],
+                'rows' => $rows,
+            ];
+
+            $total->addAmount($group['sum']);
+        }
+
+        return ['groups' => $groups, 'total' => $total];
+    }
+
+    /**
+     * Wofür der Beleg steht.
+     *
+     * `type_other` trägt seit der Pflichtangabe "Was wurde eingekauft" zu jeder Abrechnung den Zweck,
+     * nicht mehr nur bei "Sonstige Kosten". Ältere Belege haben das Feld leer -- dann bleibt die
+     * Anmerkung, und fehlt auch die, bleibt die Zelle leer. Ein Platzhalter wie "--" würde in der
+     * Belegliste nur Platz kosten.
+     */
+    private function purpose(?string $typeOther, ?string $comment): string
+    {
+        $parts = [];
+
+        foreach ([$typeOther, $comment] as $part) {
+            if (trim((string) $part) !== '') {
+                $parts[] = trim((string) $part);
+            }
+        }
+
+        return implode(' — ', $parts);
+    }
+
+    /**
+     * Ein Betrag in deutscher Schreibweise: Punkt als Tausender-, Komma als Dezimaltrennzeichen.
+     *
+     * Bewusst nicht {@see Amount::getFormattedAmount()}: Die Methode ersetzt nach `number_format` jeden
+     * Punkt durch ein Komma und macht aus 1.487,50 damit "1,487,50". Auf einer Aufstellung, in der
+     * vierstellige Beträge die Regel sind, wäre das nicht lesbar. Der Fehler steckt im Value Object und
+     * wirkt überall, wo Beträge angezeigt werden -- ihn dort zu beheben ist eine eigene Änderung.
+     *
+     * Öffentlich, weil die Vorlage sie als Callable bekommt und weil sie für sich prüfbar sein soll.
+     */
+    public static function money(Amount $amount): string
+    {
+        return number_format(round($amount->getAmount(), 2), 2, ',', '.');
+    }
+
+    /**
+     * Summiert Zeilen, die je ein `amount` oder `total` tragen.
+     *
+     * Über ein frisches Amount-Objekt, weil `Amount::addAmount()` den Empfänger verändert -- die
+     * Einzelbeträge sollen unangetastet bleiben, sie werden anschließend gedruckt.
+     *
+     * @param array<int, array<string, mixed>> $rows
+     */
+    private static function sum(array $rows): Amount
+    {
+        $sum = new Amount(0, 'Euro');
+
+        foreach ($rows as $row) {
+            /** @var Amount $amount */
+            $amount = $row['amount'] ?? $row['total'];
+            $sum->addAmount($amount);
+        }
+
+        return $sum;
+    }
+}

app/Domains/Event/Actions/CreateIncomeSurplusStatement/CreateIncomeSurplusStatementRequest.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Domains\Event\Actions\CreateIncomeSurplusStatement;
+
+use App\Models\Event;
+
+class CreateIncomeSurplusStatementRequest
+{
+    public function __construct(public readonly Event $event)
+    {
+    }
+}

app/Domains/Event/Actions/CreateIncomeSurplusStatement/CreateIncomeSurplusStatementResponse.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Domains\Event\Actions\CreateIncomeSurplusStatement;
+
+use App\ValueObjects\Amount;
+
+class CreateIncomeSurplusStatementResponse
+{
+    public bool $success = false;
+
+    public string $filename = '';
+
+    public string $pdfContent = '';
+
+    public ?string $message = null;
+
+    /**
+     * Die Zahlen, aus denen das PDF entsteht -- Einnahmen-Kategorien, Ausgaben-Gruppen und das Ergebnis.
+     *
+     * Sie stehen hier, weil sie das eigentliche Ergebnis der Action sind; das PDF ist nur ihre Darstellung.
+     * So lässt sich die Rechnung prüfen, ohne ein PDF zerlegen zu müssen.
+     *
+     * @var array{categories: array<int, array{name: string, total: Amount, entries: array<int, array{name: string, amount: Amount}>}>, total: Amount}|array{}
+     */
+    public array $income = [];
+
+    /**
+     * @var array{groups: array<int, array{name: string, sum: Amount, rows: array<int, array<string, mixed>>}>, total: Amount}|array{}
+     */
+    public array $expenses = [];
+
+    public ?Amount $result = null;
+}

app/Domains/Event/Actions/SetEventAddons/SetEventAddonsCommand.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetEventAddons;
+
+use App\ValueObjects\Amount;
+use Illuminate\Support\Str;
+
+class SetEventAddonsCommand
+{
+    public function __construct(private SetEventAddonsRequest $request)
+    {
+    }
+
+    public function execute(): SetEventAddonsResponse
+    {
+        $response = new SetEventAddonsResponse();
+
+        $this->request->event->addons = $this->normalize($this->request->addons);
+        $this->request->event->save();
+
+        $response->success = true;
+        return $response;
+    }
+
+    /**
+     * Normalisiert die rohe Addon-Definition: trimmt Titel/Beschreibung, parst den Preis (≥ 0), erzwingt den
+     * Titel als Pflichtfeld und generiert stabile Keys (Bestandsschutz für bereits gespeicherte Buchungen).
+     *
+     * @param array<int, array<string, mixed>> $addons
+     * @return array<int, array{key: string, title: string, description: string, price: float, flat: bool}>
+     */
+    private function normalize(array $addons): array
+    {
+        $normalized = [];
+        $usedKeys = [];
+
+        foreach ($addons as $addon) {
+            $title = trim((string)($addon['title'] ?? ''));
+            if ($title === '') {
+                continue;
+            }
+
+            $price = Amount::fromString((string)($addon['price'] ?? '0'))->getAmount();
+            if ($price < 0) {
+                $price = 0.0;
+            }
+
+            $key = $this->uniqueSlug((string)($addon['key'] ?? ''), $title, $usedKeys);
+            $usedKeys[] = $key;
+
+            $normalized[] = [
+                'key' => $key,
+                'title' => $title,
+                'description' => trim((string)($addon['description'] ?? '')),
+                'price' => round($price, 2),
+                'flat' => (bool)($addon['flat'] ?? false),
+            ];
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Liefert einen eindeutigen Slug: bevorzugt den bestehenden Wert, sonst aus dem Titel abgeleitet;
+     * Kollisionen werden durchnummeriert.
+     *
+     * @param array<int, string> $used
+     */
+    private function uniqueSlug(string $existing, string $title, array $used): string
+    {
+        $base = $existing !== '' ? $existing : Str::slug($title);
+        if ($base === '') {
+            $base = 'addon';
+        }
+
+        $candidate = $base;
+        $suffix = 2;
+        while (in_array($candidate, $used, true)) {
+            $candidate = $base . '-' . $suffix;
+            $suffix++;
+        }
+
+        return $candidate;
+    }
+}

app/Domains/Event/Actions/SetEventAddons/SetEventAddonsRequest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetEventAddons;
+
+use App\Models\Event;
+
+class SetEventAddonsRequest
+{
+    public Event $event;
+
+    /** @var array<int, array<string, mixed>> Rohe Addon-Definition aus dem Admin-Panel. */
+    public array $addons;
+
+    public function __construct(Event $event, array $addons)
+    {
+        $this->event = $event;
+        $this->addons = $addons;
+    }
+}

app/Domains/Event/Actions/SetEventAddons/SetEventAddonsResponse.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetEventAddons;
+
+class SetEventAddonsResponse
+{
+    public bool $success;
+    public ?string $message;
+
+    public function __construct()
+    {
+        $this->success = false;
+        $this->message = null;
+    }
+}

app/Domains/Event/Actions/SetParticipationOptions/SetParticipationOptionsCommand.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetParticipationOptions;
+
+use Illuminate\Support\Str;
+
+class SetParticipationOptionsCommand
+{
+    public function __construct(private SetParticipationOptionsRequest $request)
+    {
+    }
+
+    public function execute(): SetParticipationOptionsResponse
+    {
+        $response = new SetParticipationOptionsResponse();
+
+        $this->request->event->participation_options = $this->normalize($this->request->questions);
+        $this->request->event->save();
+
+        $response->success = true;
+        return $response;
+    }
+
+    /**
+     * Normalisiert die rohe Fragen-Definition: trimmt Labels, generiert stabile Keys/Values und verwirft
+     * unvollständige Fragen (kein Label oder keine gültige Option). Keys/Values sind innerhalb ihres
+     * Geltungsbereichs eindeutig, damit Antworten robust referenzieren können.
+     *
+     * @param array<int, array<string, mixed>> $questions
+     * @return array<int, array{key: string, title: string, label: string, options: array<int, array{value: string, label: string}>}>
+     */
+    private function normalize(array $questions): array
+    {
+        $normalized = [];
+        $usedKeys = [];
+
+        foreach ($questions as $question) {
+            // Titel ist Pflicht (Überschrift/Feldbeschriftung); die Frage ist optionaler Erklärtext.
+            $title = trim((string)($question['title'] ?? ''));
+            if ($title === '') {
+                continue;
+            }
+
+            $label = trim((string)($question['label'] ?? ''));
+
+            $options = $this->normalizeOptions($question['options'] ?? []);
+            if ($options === []) {
+                continue;
+            }
+
+            $key = $this->uniqueSlug((string)($question['key'] ?? ''), $title, $usedKeys);
+            $usedKeys[] = $key;
+
+            $normalized[] = [
+                'key' => $key,
+                'title' => $title,
+                'label' => $label,
+                'options' => $options,
+            ];
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * @param array<int, array<string, mixed>> $options
+     * @return array<int, array{value: string, label: string}>
+     */
+    private function normalizeOptions(mixed $options): array
+    {
+        if (!is_array($options)) {
+            return [];
+        }
+
+        $normalized = [];
+        $usedValues = [];
+
+        foreach ($options as $option) {
+            $label = trim((string)($option['label'] ?? ''));
+            if ($label === '') {
+                continue;
+            }
+
+            $value = $this->uniqueSlug((string)($option['value'] ?? ''), $label, $usedValues);
+            $usedValues[] = $value;
+
+            $normalized[] = ['value' => $value, 'label' => $label];
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Liefert einen eindeutigen Slug: bevorzugt den bestehenden Wert (Bestandsschutz für schon gespeicherte
+     * Fragen/Antworten), sonst aus dem Label abgeleitet; Kollisionen werden durchnummeriert.
+     *
+     * @param array<int, string> $used
+     */
+    private function uniqueSlug(string $existing, string $label, array $used): string
+    {
+        $base = $existing !== '' ? $existing : Str::slug($label);
+        if ($base === '') {
+            $base = 'option';
+        }
+
+        $candidate = $base;
+        $suffix = 2;
+        while (in_array($candidate, $used, true)) {
+            $candidate = $base . '-' . $suffix;
+            $suffix++;
+        }
+
+        return $candidate;
+    }
+}

app/Domains/Event/Actions/SetParticipationOptions/SetParticipationOptionsRequest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetParticipationOptions;
+
+use App\Models\Event;
+
+class SetParticipationOptionsRequest
+{
+    public Event $event;
+
+    /** @var array<int, array<string, mixed>> Rohe Fragen-Definition aus dem Admin-Panel. */
+    public array $questions;
+
+    public function __construct(Event $event, array $questions)
+    {
+        $this->event = $event;
+        $this->questions = $questions;
+    }
+}

app/Domains/Event/Actions/SetParticipationOptions/SetParticipationOptionsResponse.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Domains\Event\Actions\SetParticipationOptions;
+
+class SetParticipationOptionsResponse
+{
+    public bool $success;
+    public ?string $message;
+
+    public function __construct()
+    {
+        $this->success = false;
+        $this->message = null;
+    }
+}

app/Domains/Event/Actions/SignUp/SignUpCommand.php

@@ -6,6 +6,7 @@ use App\Enumerations\EatingHabit;
 use App\Enumerations\EfzStatus;
 use App\EventPaymentModules\EventPaymentModuleRegistry;
 use App\ValueObjects\Age;
+use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Str;
 
 class SignUpCommand {
@@ -27,6 +28,14 @@ class SignUpCommand {
             return $response;
         }
 
+        // Teilnahmeoptionen (event-spezifische Pflicht-Auswahl) gegen die Event-Definition absichern.
+        $participationOptionRows = $this->buildParticipationOptionRows();
+        if ($participationOptionRows === null) {
+            $response->success = false;
+            $response->message = 'Bitte alle Auswahlfelder ausfüllen.';
+            return $response;
+        }
+
         $eatingHabit = match ($this->request->eating_habit) {
             'vegan' => EatingHabit::EATING_HABIT_VEGAN,
             'vegetarian' => EatingHabit::EATING_HABIT_VEGETARIAN,
@@ -35,15 +44,21 @@ class SignUpCommand {
 
         $participantAge = new Age($this->request->birthday);
 
-        $response->participant = $this->request->event->participants()->create(
+        // Anmeldung als Ganzes: die laufende Nummer (invoice_sequence) muss unter der Sperre vergeben und
+        // im selben Zug geschrieben werden, sonst könnten zwei gleichzeitige Anmeldungen dieselbe erhalten.
+        $response->participant = DB::transaction(function () use ($participantAge, $eatingHabit, $paymentOptions, $participationOptionRows) {
+            $participant = $this->request->event->participants()->create(
             [
                 'tenant' => $this->request->event->tenant,
                 'user_id' => $this->request->user_id,
                 'identifier' => Str::random(10),
+                'invoice_sequence' => $this->nextInvoiceSequence(),
                 'firstname' => $this->request->firstname,
                 'lastname' => $this->request->lastname,
                 'nickname' => $this->request->nickname,
                 'participation_type' => $this->request->participationType,
+                'fee_type' => $this->request->feeType,
+                'sibling_reduction' => $this->request->siblingReduction,
                 'local_group' => $this->request->localGroup->slug,
                 'birthday' => $this->request->birthday,
                 'address_1' => $this->request->address_1,
@@ -60,8 +75,12 @@ class SignUpCommand {
                 'medications' => $this->request->medications,
                 'tetanus_vaccination' => $this->request->tetanus_vaccination,
                 'eating_habit' => $eatingHabit,
-                'swimming_permission' => $participantAge->isfullAged() ? 'SWIMMING_PERMISSION_ALLOWED' : $this->request->swimming_permission,
+                'swimming_permission' => ($participantAge->isfullAged() || $this->request->swimming_permission === '-1')
-                'first_aid_permission' => $participantAge->isfullAged() ? 'FIRST_AID_PERMISSION_ALLOWED' : $this->request->first_aid_permission,
+                    ? 'SWIMMING_PERMISSION_ALLOWED'
+                    : $this->request->swimming_permission,
+                'first_aid_permission' => ($participantAge->isfullAged() || $this->request->first_aid_permission === '-1')
+                    ? 'FIRST_AID_PERMISSION_ALLOWED'
+                    : $this->request->first_aid_permission,
                 'foto_socialmedia' => $this->request->foto_socialmedia,
                 'foto_print' => $this->request->foto_print,
                 'foto_webseite' => $this->request->foto_webseite,
@@ -80,8 +99,114 @@ class SignUpCommand {
             ]
             );
 
+            $this->persistParticipationOptions($participant, $participationOptionRows);
+            $this->persistAddons($participant);
+
+            return $participant;
+        });
+
         $response->success = true;
         return $response;
     }
 
+    /**
+     * Nächste laufende Nummer des Teilis innerhalb der Veranstaltung -- der letzte Block der
+     * Rechnungsnummer. Die Event-Zeile wird gesperrt, damit gleichzeitige Anmeldungen derselben
+     * Veranstaltung serialisiert werden; der Aufruf erfolgt innerhalb der Anmelde-Transaktion, sodass die
+     * Sperre bis zum Schreiben des Teilis steht.
+     *
+     * Abgemeldete Teilis behalten ihre Nummer, gezählt wird deshalb über MAX und nicht über COUNT.
+     */
+    private function nextInvoiceSequence(): int
+    {
+        DB::table('events')
+            ->where('id', $this->request->event->id)
+            ->lockForUpdate()
+            ->first();
+
+        $highest = DB::table('event_participants')
+            ->where('event_id', $this->request->event->id)
+            ->max('invoice_sequence');
+
+        return (int) $highest + 1;
+    }
+
+    /**
+     * Speichert die gewählten Zusätze (Event-Addons) als Snapshot-Zeilen (Titel/Preis/Betrag) für die spätere
+     * Rechnung. Die Beträge sind bereits in der Controller-Auflösung (`resolveAddons`) berechnet, inkl. USt.
+     */
+    private function persistAddons(\App\Models\EventParticipant $participant): void
+    {
+        foreach ($this->request->addonItems as $item) {
+            $participant->selectedAddons()->create([
+                'tenant' => $this->request->event->tenant,
+                'event_id' => $this->request->event->id,
+                'addon_key' => $item['key'],
+                'title' => $item['title'],
+                'price' => $item['price'] ?? 0,
+                'flat' => (bool)($item['flat'] ?? false),
+                'days' => $item['days'] ?? 0,
+                'amount' => $item['amount'] ?? 0,
+            ]);
+        }
+    }
+
+    /**
+     * Validiert die Antworten gegen die am Event definierten Teilnahmeoptionen und erzeugt die zu speichernden
+     * Zeilen mit Label-Snapshots. Gibt null zurück, wenn eine Pflicht-Frage unbeantwortet oder eine Antwort
+     * ungültig ist (Absicherung gegen manipulierte Payloads).
+     *
+     * @return array<int, array{question_key: string, question_label: string, value: string, value_label: string}>|null
+     */
+    private function buildParticipationOptionRows(): ?array
+    {
+        $rows = [];
+
+        foreach ($this->request->event->participation_options ?? [] as $question) {
+            $key = $question['key'] ?? null;
+            if ($key === null) {
+                continue;
+            }
+
+            $value = $this->request->participationOptions[$key] ?? null;
+            if ($value === null || $value === '') {
+                return null;
+            }
+
+            $option = null;
+            foreach ($question['options'] ?? [] as $candidate) {
+                if (($candidate['value'] ?? null) === $value) {
+                    $option = $candidate;
+                    break;
+                }
+            }
+
+            if ($option === null) {
+                return null;
+            }
+
+            $rows[] = [
+                'question_key' => $key,
+                'question_label' => $question['label'] ?? $key,
+                'value' => $value,
+                'value_label' => $option['label'] ?? $value,
+            ];
+        }
+
+        return $rows;
+    }
+
+    /**
+     * @param array<int, array{question_key: string, question_label: string, value: string, value_label: string}> $rows
+     */
+    private function persistParticipationOptions(\App\Models\EventParticipant $participant, array $rows): void
+    {
+        foreach ($rows as $row) {
+            $participant->selectedOptions()->create(array_merge($row, [
+                'tenant' => $this->request->event->tenant,
+                'event_id' => $this->request->event->id,
+            ]));
+        }
+    }
+
 }

app/Domains/Event/Actions/SignUp/SignUpRequest.php

@@ -46,6 +46,14 @@ class SignUpRequest {
         public Amount $amount,
         public ?string $paymentMethod,
         public array $paymentOptions = [],
+        /** Antworten auf die Teilnahmeoptionen: [ question_key => value ]. */
+        public array $participationOptions = [],
+        /** Aufgelöste Zusätze (Event-Addons): je Eintrag [ key, title, price, flat, days, amount ]. */
+        public array $addonItems = [],
+        /** Gewählte Preisspalte: standard | reduced | solidarity. Wird für die Rechnung mitgeschrieben. */
+        public ?string $feeType = null,
+        /** Ob die 50-%-Geschwisterermäßigung in `amount` eingerechnet ist. */
+        public bool $siblingReduction = false,
     ) {
     }
 }

app/Domains/Event/Actions/UpdateParticipant/UpdateParticipantCommand.php

@@ -72,11 +72,97 @@ class UpdateParticipantCommand {
 
 
         $p->save();
+
+        if ($this->request->participationOptions !== null) {
+            $this->syncParticipationOptions($p);
+        }
+
+        if ($this->request->selectedAddons !== null) {
+            $this->syncAddons($p);
+        }
+
         $this->response->success = true;
         $this->response->participant = $p;
         return $this->response;
     }
 
+    /**
+     * Ersetzt die zugeordneten Zusätze (Event-Addons) anhand der Auswahl. Bewusst **ohne Preis/Betrag**
+     * (amount 0): der Teilnahmebeitrag wird in den Details ohnehin manuell gesetzt. Es wird nur der Titel als
+     * Snapshot gespeichert, damit die Zuordnung sichtbar bleibt.
+     */
+    private function syncAddons(EventParticipant $participant): void
+    {
+        $participant->selectedAddons()->delete();
+
+        $selection = $this->request->selectedAddons ?? [];
+
+        foreach ($participant->event?->addons ?? [] as $addon) {
+            $key = $addon['key'] ?? null;
+            if ($key === null || empty($selection[$key])) {
+                continue;
+            }
+
+            $participant->selectedAddons()->create([
+                'tenant' => $participant->tenant,
+                'event_id' => $participant->event_id,
+                'addon_key' => $key,
+                'title' => $addon['title'] ?? $key,
+                'price' => 0,
+                'flat' => (bool)($addon['flat'] ?? false),
+                'days' => 0,
+                'amount' => 0,
+            ]);
+        }
+    }
+
+    /**
+     * Ersetzt die zugeordneten Teilnahmeoptionen anhand der übergebenen Antworten. Nachträgliche Zuordnung im
+     * Back-Office ist lückenlos möglich: nur gegen die Event-Definition gültige Antworten werden gespeichert,
+     * leere/entfallene Antworten werden abgeräumt. Frage-/Options-Label werden als Snapshot mitgeschrieben.
+     */
+    private function syncParticipationOptions(EventParticipant $participant): void
+    {
+        $participant->selectedOptions()->delete();
+
+        $answers = $this->request->participationOptions ?? [];
+
+        foreach ($participant->event?->participation_options ?? [] as $question) {
+            $key = $question['key'] ?? null;
+            if ($key === null) {
+                continue;
+            }
+
+            $value = $answers[$key] ?? null;
+            if ($value === null || $value === '') {
+                continue;
+            }
+
+            $option = null;
+            foreach ($question['options'] ?? [] as $candidate) {
+                if (($candidate['value'] ?? null) === $value) {
+                    $option = $candidate;
+                    break;
+                }
+            }
+
+            if ($option === null) {
+                continue;
+            }
+
+            $label = trim((string)($question['label'] ?? ''));
+
+            $participant->selectedOptions()->create([
+                'tenant' => $participant->tenant,
+                'event_id' => $participant->event_id,
+                'question_key' => $key,
+                'question_label' => $label !== '' ? $label : ($question['title'] ?? $key),
+                'value' => $value,
+                'value_label' => $option['label'] ?? $value,
+            ]);
+        }
+    }
+
     private function handleAmountChanges(EventParticipant $participant) {
         $this->response->amountPaid = $participant->amount_paid;
         $this->response->amountExpected = $participant->amount;

app/Domains/Event/Actions/UpdateParticipant/UpdateParticipantRequest.php

@@ -36,5 +36,9 @@ class UpdateParticipantRequest {
         public string $amountPaid,
         public string $amountExpected,
         public string $cocStatus,
+        /** Antworten auf die Teilnahmeoptionen: [ question_key => value ]. null = unverändert lassen. */
+        public ?array $participationOptions = null,
+        /** Gewählte Zusätze: [ addon_key => bool ]. null = unverändert lassen. */
+        public ?array $selectedAddons = null,
     ) {}
 }

app/Domains/Event/Controllers/DetailsController.php

@@ -2,8 +2,12 @@
 
 namespace App\Domains\Event\Controllers;
 
+use App\Domains\Event\Actions\SetEventAddons\SetEventAddonsCommand;
+use App\Domains\Event\Actions\SetEventAddons\SetEventAddonsRequest;
 use App\Domains\Event\Actions\SetParticipationFees\SetParticipationFeesCommand;
 use App\Domains\Event\Actions\SetParticipationFees\SetParticipationFeesRequest;
+use App\Domains\Event\Actions\SetParticipationOptions\SetParticipationOptionsCommand;
+use App\Domains\Event\Actions\SetParticipationOptions\SetParticipationOptionsRequest;
 use App\Domains\Event\Actions\SetPaymentMethods\SetPaymentMethodsCommand;
 use App\Domains\Event\Actions\SetPaymentMethods\SetPaymentMethodsRequest;
 use App\Domains\Event\Actions\UpdateEvent\UpdateEventCommand;
@@ -142,6 +146,28 @@ class DetailsController extends CommonController {
         return response()->json(['status' => $response->success ? 'success' : 'error']);
     }
 
+    public function updateParticipationOptions(int $eventId, Request $request): JsonResponse
+    {
+        $event = $this->events->getById($eventId);
+
+        $setRequest = new SetParticipationOptionsRequest($event, (array)$request->input('questions', []));
+        $setCommand = new SetParticipationOptionsCommand($setRequest);
+        $response = $setCommand->execute();
+
+        return response()->json(['status' => $response->success ? 'success' : 'error', 'message' => $response->message]);
+    }
+
+    public function updateEventAddons(int $eventId, Request $request): JsonResponse
+    {
+        $event = $this->events->getById($eventId);
+
+        $setRequest = new SetEventAddonsRequest($event, (array)$request->input('addons', []));
+        $setCommand = new SetEventAddonsCommand($setRequest);
+        $response = $setCommand->execute();
+
+        return response()->json(['status' => $response->success ? 'success' : 'error', 'message' => $response->message]);
+    }
+
     public function downloadPdfList(string $eventId, string $listType, Request $request): Response
     {
         $event = $this->events->getByIdentifier($eventId);
@@ -195,6 +221,12 @@ class DetailsController extends CommonController {
             case 'by-participation-group':
                 $participants = $this->eventParticipants->groupByParticipationType($event, $request);
                 break;
+            case 'by-participation-option':
+                $participants = $this->eventParticipants->groupByParticipationOption($event, $request);
+                break;
+            case 'by-addon':
+                $participants = $this->eventParticipants->groupByAddon($event, $request);
+                break;
             case 'signed-off':
                 $participants = $this->eventParticipants->getSignedOffParticipants($event, $request);
                 break;

app/Domains/Event/Controllers/IncomeSurplusStatementController.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Domains\Event\Controllers;
+
+use App\Domains\Event\Actions\CreateIncomeSurplusStatement\CreateIncomeSurplusStatementCommand;
+use App\Domains\Event\Actions\CreateIncomeSurplusStatement\CreateIncomeSurplusStatementRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\Response;
+
+class IncomeSurplusStatementController extends CommonController
+{
+    public function __invoke(string $eventId): Response
+    {
+        $event = $this->events->getByIdentifier($eventId);
+
+        if ($event === null) {
+            abort(403, 'Zugriff verweigert.');
+        }
+
+        $statementRequest = new CreateIncomeSurplusStatementRequest($event);
+        $statementCommand = new CreateIncomeSurplusStatementCommand($statementRequest);
+        $statementResponse = $statementCommand->execute();
+
+        if (!$statementResponse->success) {
+            abort(422, $statementResponse->message ?? 'Die EÜR konnte nicht erstellt werden.');
+        }
+
+        return response($statementResponse->pdfContent, 200, [
+            'Content-Type' => 'application/pdf',
+            'Content-Disposition' => 'attachment; filename="' . $statementResponse->filename . '"',
+        ]);
+    }
+}

app/Domains/Event/Controllers/MailCompose/ByGroupController.php

@@ -19,6 +19,10 @@ class ByGroupController extends CommonController
                 $participants = $this->eventParticipants->groupByParticipationType($event, $request, $request->input('groupName'));
                 $recipients = $this->eventParticipants->getMailAddresses($participants[$request->input('groupName')]);
                 break;
+            case 'by-participation-option':
+                $participants = $this->eventParticipants->groupByParticipationOption($event, $request, $request->input('groupName'));
+                $recipients = $this->eventParticipants->getMailAddresses($participants[$request->input('groupName')] ?? []);
+                break;
             case 'signed-off':
                 $participants = $this->eventParticipants->getSignedOffParticipants($event, $request, $request->input('groupName'));
                 $recipients = $this->eventParticipants->getMailAddresses($participants[$request->input('groupName')]);

app/Domains/Event/Controllers/ParticipantUpdateController.php

@@ -44,6 +44,8 @@ class ParticipantUpdateController extends CommonController {
             amountPaid: $request->input('amountPaid'),
             amountExpected: $request->input('amountExpected'),
             cocStatus: $request->input('cocStatus'),
+            participationOptions: $request->has('participationOptions') ? (array)$request->input('participationOptions') : null,
+            selectedAddons: $request->has('selectedAddons') ? (array)$request->input('selectedAddons') : null,
         );
 
         $command = new UpdateParticipantCommand($updateRequest);

app/Domains/Event/Controllers/SignupController.php

@@ -12,6 +12,7 @@ use App\Providers\DoubleCheckEventRegistrationProvider;
 use App\Providers\InertiaProvider;
 use App\Resources\UserResource;
 use App\Scopes\CommonController;
+use App\ValueObjects\Amount;
 use DateTime;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
@@ -104,6 +105,11 @@ class SignupController extends CommonController {
             $siblingReduction
         );
 
+        // Gewählte Zusätze (Event-Addons) auflösen und auf den Gesamtbetrag aufaddieren.
+        $selectedAddonKeys = array_keys(array_filter((array)$request->input('addons', []), fn($v) => (bool)$v));
+        $addonResolution = $eventResource->resolveAddons($selectedAddonKeys, $arrival, $departure);
+        $amount->addAmount($addonResolution['total']);
+
         $signupRequest = new SignUpRequest(
             $event,
             $registrationData['userId'] ?? null,
@@ -142,6 +148,10 @@ class SignupController extends CommonController {
             $amount,
             $registrationData['paymentMethod'] ?? null,
             (array)($registrationData['paymentOptions'] ?? []),
+            (array)($registrationData['participationOptions'] ?? []),
+            $addonResolution['items'],
+            $registrationData['beitrag'],
+            $siblingReduction,
         );
 
         $signupCommand = new SignUpCommand($signupRequest);
@@ -184,18 +194,41 @@ class SignupController extends CommonController {
 
         $siblingReduction = $request->input('sibling') === 'true';
 
-        $amount = $event->calculateAmount(
+        $arrival = \DateTime::createFromFormat('Y-m-d', $request->input('arrival'));
+        $departure = \DateTime::createFromFormat('Y-m-d', $request->input('departure'));
+
+        $baseFee = $event->calculateAmount(
             $request->input('participationType'),
             $request->input('beitrag'),
-            \DateTime::createFromFormat('Y-m-d', $request->input('arrival')),
+            $arrival,
-            \DateTime::createFromFormat('Y-m-d', $request->input('departure')),
+            $departure,
             $siblingReduction
         );
 
+        // Gewählte Zusätze immer einrechnen -- so enthält der finale Anzeigebetrag (und der Bestätigungstext)
+        // stets die Addons und der Zahlungsschritt wird nur bei Gesamt 0 € übersprungen.
+        $selectedAddonKeys = array_keys(array_filter((array)$request->input('addons', []), fn($v) => (bool)$v));
+        $resolution = $event->resolveAddons($selectedAddonKeys, $arrival, $departure);
+
+        // Gesamt = Teilnahmebeitrag + Zusätze; Basisbetrag separat für die Kostenübersicht in der Zusammenfassung.
+        $total = new Amount($baseFee->getAmount(), 'Euro');
+        $total->addAmount($resolution['total']);
+
+        $addonLines = array_map(fn($item) => [
+            'key' => $item['key'],
+            'title' => $item['title'],
+            'amountValue' => $item['amount'],
+            'amount' => new Amount($item['amount'], 'Euro')->toString(),
+            'free' => $item['amount'] <= 0,
+        ], $resolution['items']);
+
         // amountValue (numerisch) steuert im Frontend das Überspringen des Zahlungsart-Schritts bei 0 €.
         return response()->json([
-            'amount' => $amount->toString(),
+            'amount' => $total->toString(),
-            'amountValue' => $amount->getAmount(),
+            'amountValue' => $total->getAmount(),
+            'baseAmount' => $baseFee->toString(),
+            'baseAmountValue' => $baseFee->getAmount(),
+            'addons' => $addonLines,
         ]);
     }
 }

app/Domains/Event/Routes/api.php

@@ -46,6 +46,8 @@ Route::prefix('api/v1')
                         Route::post('/participation-fees', [DetailsController::class, 'updateParticipationFees']);
                         Route::post('/common-settings', [DetailsController::class, 'updateCommonSettings']);
                         Route::post('/payment-methods', [DetailsController::class, 'updatePaymentMethods']);
+                        Route::post('/participation-options', [DetailsController::class, 'updateParticipationOptions']);
+                        Route::post('/event-addons', [DetailsController::class, 'updateEventAddons']);
                     });
 
 

app/Domains/Event/Routes/web.php

@@ -4,6 +4,7 @@ use App\Domains\Event\Controllers\ArchivedEventsController;
 use App\Domains\Event\Controllers\AvailableEventsController;
 use App\Domains\Event\Controllers\CreateController;
 use App\Domains\Event\Controllers\DetailsController;
+use App\Domains\Event\Controllers\IncomeSurplusStatementController;
 use App\Domains\Event\Controllers\SignupController;
 use App\Middleware\IdentifyTenant;
 use Illuminate\Support\Facades\Route;
@@ -18,6 +19,10 @@ Route::middleware(IdentifyTenant::class)->group(function () {
 
         Route::middleware(['auth'])->group(function () {
             Route::get('/details/{eventId}', DetailsController::class);
+
+            // Vor der Wildcard darunter: Sonst greift `downloadPdfList()` und sucht ein Blade namens
+            // `income-surplus-statement` mit Teilnehmendendaten, die die EÜR gar nicht braucht.
+            Route::get('/details/{eventId}/pdf/income-surplus-statement', IncomeSurplusStatementController::class);
             Route::get('/details/{eventId}/pdf/{listType}', [DetailsController::class, 'downloadPdfList']);
             Route::get('/details/{eventId}/csv/{listType}', [DetailsController::class, 'downloadCsvList']);
         });

app/Domains/Event/Views/Details.vue

@@ -1,9 +1,11 @@
 <script setup>
-import {reactive, inject, onMounted} from 'vue';
+import {onMounted} from 'vue';
 import AppLayout from "../../../../resources/js/layouts/AppLayout.vue";
 import ShadowedBox from "../../../Views/Components/ShadowedBox.vue";
 import TabbedPage from "../../../Views/Components/TabbedPage.vue";
 import ParticipantsList from "./Partials/ParticipantsList.vue";
+import ParticipantsByOption from "./Partials/ParticipantsByOption.vue";
+import ParticipantsByAddon from "./Partials/ParticipantsByAddon.vue";
 import Overview from "./Partials/Overview.vue";
 
 const props = defineProps({
@@ -31,16 +33,21 @@ const tabs = [
         component: ParticipantsList,
         endpoint: "/api/v1/event/details/" + props.event.identifier + '/participants/by-participation-group',
     },
+    {
+        title: 'Teilis nach Teilnahmeoption',
+        component: ParticipantsByOption,
+        endpoint: "/api/v1/event/details/" + props.event.identifier + '/participants/by-participation-option',
+    },
+    {
+        title: 'Teilis mit Zusatzoptionen',
+        component: ParticipantsByAddon,
+        endpoint: "/api/v1/event/details/" + props.event.identifier + '/participants/by-addon',
+    },
     {
         title: 'Abgemeldete Teilis',
         component: ParticipantsList,
         endpoint: "/api/v1/event/details/" + props.event.identifier + '/participants/signed-off',
     },
-    {
-        title: 'Zusätze',
-        component: ParticipantsList,
-        endpoint: "/api/v1/cost-unit/open/archived-cost-units",
-    },
 ]
 
 onMounted(() => {

app/Domains/Event/Views/Partials/EventAddons.vue

@@ -0,0 +1,166 @@
+<script setup>
+import {ref} from "vue";
+import {toast} from "vue3-toastify";
+import {request} from "../../../../../resources/js/components/HttpClient.js";
+import AmountInput from "../../../../Views/Components/AmountInput.vue";
+
+const emit = defineEmits(['close'])
+
+const props = defineProps({
+    event: Object,
+})
+
+// Addon-Definition dieses Events: [ { key, title, description, price, flat } ].
+// key bleibt für bestehende Einträge erhalten (Bestandsschutz für bereits gebuchte Zusätze).
+const addons = ref((props.event.addons ?? []).map(a => ({
+    key: a.key ?? '',
+    title: a.title ?? '',
+    description: a.description ?? '',
+    price: a.price != null ? String(a.price).replace('.', ',') : '0',
+    flat: a.flat ?? false,
+})))
+
+function addAddon() {
+    addons.value.push({key: '', title: '', description: '', price: '0', flat: true})
+}
+
+function removeAddon(index) {
+    addons.value.splice(index, 1)
+}
+
+function validate() {
+    for (const addon of addons.value) {
+        if (addon.title.trim() === '') {
+            toast.error('Bitte für jeden Zusatz einen Titel angeben.')
+            return false
+        }
+    }
+
+    return true
+}
+
+async function save() {
+    if (!validate()) {
+        return
+    }
+
+    const response = await request('/api/v1/event/details/' + props.event.id + '/event-addons', {
+        method: 'POST',
+        body: {
+            addons: addons.value,
+        }
+    })
+
+    if (response.status !== 'success') {
+        toast.error(response.message ?? 'Die Zusatzoptionen konnten nicht gespeichert werden.')
+        return
+    }
+
+    toast.success('Die Zusatzoptionen wurden gespeichert')
+    emit('close')
+}
+</script>
+
+<template>
+    <div class="event-addons">
+        <h3>Zusatzoptionen</h3>
+        <p style="color: #6b7280; font-size: 0.9rem;">
+            Buchbare Zusätze zur Veranstaltung (z. B. Parkticket, Aufnäher). Jede Position ist eine Ja/Nein-Auswahl.
+            Preis 0 wird dem Teilnehmenden als „Kostenfrei" angezeigt. Ist „Pauschale" nicht gesetzt, wird der Preis
+            mit der Anzahl der Teilnahmetage multipliziert. Ohne Zusätze wird dieser Schritt in der Anmeldung
+            übersprungen.
+        </p>
+
+        <div v-for="(addon, index) in addons" :key="index" class="addon-card">
+            <div class="addon-head">
+                <div class="addon-fields">
+                    <label class="field-label">Titel</label>
+                    <input type="text" v-model="addon.title" class="width-full" placeholder="z. B. „Parkticket“"/>
+
+                    <label class="field-label">Beschreibung (optional)</label>
+                    <input type="text" v-model="addon.description" class="width-full" placeholder="Kurze Erläuterung"/>
+
+                    <div class="addon-price-row">
+                        <span>
+                            <label class="field-label">Preis</label>
+                            <AmountInput v-model="addon.price" class="width-small"/> Euro
+                        </span>
+                        <label class="flat-label">
+                            <input type="checkbox" v-model="addon.flat"/>
+                            Pauschale (nicht pro Tag)
+                        </label>
+                    </div>
+                </div>
+                <label class="link remove-link" @click="removeAddon(index)">Entfernen</label>
+            </div>
+        </div>
+
+        <div style="margin-top: 16px;">
+            <label class="link" @click="addAddon">+ Zusatz hinzufügen</label>
+        </div>
+
+        <div style="margin-top: 24px;">
+            <input type="button" value="Speichern" @click="save"/>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+.addon-card {
+    margin-top: 16px;
+    padding: 14px;
+    background: #f8fafc;
+    border: 1px solid #e5e7eb;
+    border-radius: 10px;
+}
+
+.addon-head {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+}
+
+.addon-fields {
+    flex: 1;
+}
+
+.field-label {
+    display: block;
+    font-size: 0.78rem;
+    color: #6b7280;
+    margin: 6px 0 2px;
+}
+
+.addon-fields .field-label:first-child {
+    margin-top: 0;
+}
+
+.addon-price-row {
+    display: flex;
+    align-items: flex-end;
+    gap: 24px;
+    margin-top: 6px;
+}
+
+.flat-label {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 0.9rem;
+    color: #374151;
+}
+
+.width-full {
+    width: 100%;
+}
+
+.width-small {
+    width: 90px;
+}
+
+.remove-link {
+    white-space: nowrap;
+    color: #ef4444;
+    font-size: 0.85rem;
+}
+</style>

app/Domains/Event/Views/Partials/Overview.vue

@@ -1,6 +1,8 @@
 <script setup>
 import {onMounted, reactive, ref} from "vue";
 import ParticipationFees from "./ParticipationFees.vue";
+import ParticipationOptions from "./ParticipationOptions.vue";
+import EventAddons from "./EventAddons.vue";
 import ParticipationSummary from "./ParticipationSummary.vue";
 import CommonSettings from "./CommonSettings.vue";
 import EventManagement from "./EventManagement.vue";
@@ -36,6 +38,14 @@
         displayData.value = 'participationFees';
     }
 
+    async function showParticipationOptions() {
+        displayData.value = 'participationOptions';
+    }
+
+async function showEventAddons() {
+    displayData.value = 'eventAddons';
+}
+
     async function showEventManagement() {
         displayData.value = 'eventManagement';
     }
@@ -96,6 +106,10 @@
             <input type="button" value="Beitragsliste (PDF)" />
         </a><br/>
 
+        <a :href="'/event/details/' + props.data.event.identifier + '/pdf/income-surplus-statement'">
+            <input type="button" value="EüR (PDF)" />
+        </a><br/>
+
         <a :href="'/event/details/' + props.data.event.identifier + '/pdf/drinking-list'">
             <input type="button" value="Getränkeliste (PDF)" />
         </a><br/>
@@ -107,6 +121,9 @@
 
 
     <ParticipationFees v-if="displayData === 'participationFees'" :event="dynamicProps.event"  @close="showMain" />
+    <ParticipationOptions v-else-if="displayData === 'participationOptions'" :event="dynamicProps.event"
+                          @close="showMain"/>
+    <EventAddons v-else-if="displayData === 'eventAddons'" :event="dynamicProps.event" @close="showMain"/>
     <CommonSettings v-else-if="displayData === 'commonSettings'" :event="dynamicProps.event"  @close="showMain" />
     <EventManagement v-else-if="displayData === 'eventManagement'" :event="dynamicProps.event"  @close="showMain" />
 
@@ -130,6 +147,10 @@
                     <input type="button" value="Beitragsliste (PDF)" />
                 </a><br/>
 
+                <a :href="'/event/details/' + props.data.event.identifier + '/pdf/income-surplus-statement'">
+                    <input type="button" value="EüR (PDF)" />
+                </a><br/>
+
                 <a :href="'/event/details/' + props.data.event.identifier + '/pdf/drinking-list'">
                     <input type="button" value="Getränkeliste (PDF)" />
                 </a><br/>
@@ -185,7 +206,10 @@
         <div class="event-flexbox-row bottom">
             <label style="font-size: 9pt;" class="link" @click="showCommonSettings">Allgemeine Einstellungen</label> &nbsp;
             <label style="font-size: 9pt;" class="link" @click="showEventManagement">Veranstaltungsleitung</label> &nbsp;
-            <label style="font-size: 9pt;" class="link" @click="showParticipationFees">Teilnahmegebühren</label>
+            <label style="font-size: 9pt;" class="link" @click="showParticipationFees">Teilnahmegebühren</label> &nbsp;
+            <label style="font-size: 9pt;" class="link" @click="showParticipationOptions">Teilnahmeoptionen</label>
+            &nbsp;
+            <label style="font-size: 9pt;" class="link" @click="showEventAddons">Zusatzoptionen</label>
             <a style="font-size: 9pt;" class="link" :href="'/budget/' + props.data.event.costUnit.id">Budget bearbeiten</a>
             <a style="font-size: 9pt;" class="link" :href="'/cost-unit/' + props.data.event.costUnit.id">Ausgabenübersicht</a>
             <a v-if="!dynamicProps.event.registrationAllowed && !dynamicProps.event.archived" style="color: #ff0000; font-size: 9pt;" class="link" @click="archiveEvent">Archivieren</a>

app/Domains/Event/Views/Partials/ParticipantData.vue

@@ -1,7 +1,11 @@
 <script setup>
-import {onMounted, reactive, watch} from "vue";
+import {computed, onMounted, reactive, ref, watch} from "vue";
+import {toast} from "vue3-toastify";
 import AmountInput from "../../../../Views/Components/AmountInput.vue";
 import DialableTelephoneNumber from "../../../../Views/Components/DialableTelephoneNumber.vue";
+import {useAjax} from "../../../../../resources/js/components/ajaxHandler.js";
+
+const {download} = useAjax();
 
 const staticProps = defineProps({
     editMode: Boolean,
@@ -60,8 +64,27 @@ const form = reactive({
     amountPaid: '',
     amountExpected: '',
     cocStatus: '',
+    participationOptions: {},
+    selectedAddons: {},
 });
 
+// Teilnahmeoptionen des Events (Definition mit Titel/Frage/Optionen).
+const participationQuestions = computed(() => staticProps.event?.participationOptions ?? []);
+
+// Zusatzoptionen (Event-Addons) des Events.
+const eventAddons = computed(() => staticProps.event?.addons ?? []);
+
+// Gewählte Antwort (Options-Label) eines Teilnehmers zu einer Frage – für die Ansicht „Titel: Antwort".
+function answerLabelFor(questionKey) {
+    const answer = (props.participant?.participationOptions ?? []).find(o => o.questionKey === questionKey);
+    return answer?.valueLabel ?? '—';
+}
+
+// Hat der Teilnehmer diesen Zusatz gebucht? – für die Ansicht.
+function isAddonSelected(addonKey) {
+    return (props.participant?.selectedAddons ?? []).some(a => a.addonKey === addonKey);
+}
+
 watch(
     () => props.participant,
     (participant) => {
@@ -94,6 +117,12 @@ watch(
         form.amountPaid = participant?.amountPaid.short ?? '';
         form.amountExpected = participant?.amountExpected.short ?? '';
         form.cocStatus = participant?.efz_status ?? '';
+        form.participationOptions = Object.fromEntries(
+            (participant?.participationOptions ?? []).map(o => [o.questionKey, o.value])
+        );
+        form.selectedAddons = Object.fromEntries(
+            (participant?.selectedAddons ?? []).map(a => [a.addonKey, true])
+        );
     },
     { immediate: true }
 );
@@ -121,6 +150,31 @@ function enableEditMode() {
     emit('editParticipant');
 }
 
+/**
+ * Rechnung über den Teilnahmebeitrag herunterladen. Sie wird bei jedem Klick neu erzeugt und trägt immer
+ * dieselbe, aus Veranstaltung und Position des Teilis abgeleitete Nummer.
+ *
+ * Bei einem Beitrag von 0 € gibt es nichts zu berechnen -- dann entfällt der Knopf.
+ */
+const creatingInvoice = ref(false)
+
+const hasAmount = computed(() => Number(props.participant?.amountExpectedValue ?? 0) > 0)
+
+async function downloadInvoice() {
+    creatingInvoice.value = true
+
+    try {
+        // Der Dateiname (mit der Rechnungsnummer) kommt aus dem Content-Disposition-Header.
+        const ok = await download('/api/v1/participant-invoice/' + staticProps.participant.identifier)
+
+        if (!ok) {
+            toast.error('Die Rechnung konnte nicht erstellt werden.')
+        }
+    } finally {
+        creatingInvoice.value = false
+    }
+}
+
 function saveParticipant() {
     emit('saveParticipant', { ...form });
     close();
@@ -323,6 +377,27 @@ function saveParticipant() {
                             </span>
                         </td>
                     </tr>
+                    <tr v-if="props.participant.refund">
+                        <th>Erstattung</th>
+                        <td>
+                            {{ props.participant.refund.amount }} &ndash; {{ props.participant.refund.reasonLabel }}<br />
+                            <small v-if="props.participant.refund.status === 'pending'">
+                                freigegeben am {{ props.participant.refund.releasedAt }}, wartet auf die
+                                Bankverbindung des Teilis
+                            </small>
+                            <small v-else-if="props.participant.refund.status === 'accepted'">
+                                bestätigt am {{ props.participant.refund.acceptedAt }}
+                            </small>
+
+                            <!-- Was beim Verband geblieben ist und warum. -->
+                            <small v-if="props.participant.refund.hasRetention" class="retention-note">
+                                <br />Einbehalten: {{ props.participant.refund.retainedAmount }} &ndash;
+                                {{ props.participant.refund.retentionReasonLabel }}<template
+                                    v-if="props.participant.refund.retentionReasonNote"
+                                > ({{ props.participant.refund.retentionReasonNote }})</template>
+                            </small>
+                        </td>
+                    </tr>
                 </table>
             </div>
 
@@ -388,6 +463,43 @@ function saveParticipant() {
                 </table>
             </div>
         </div>
+
+        <div class="participationData" v-if="participationQuestions.length > 0 || eventAddons.length > 0">
+            <div>
+                <template v-if="participationQuestions.length > 0">
+                    <h3>Teilnahmeoptionen</h3>
+                    <table>
+                        <tr v-for="question in participationQuestions" :key="question.key">
+                            <th>{{ question.title || question.label }}</th>
+                            <td>
+                                <span v-if="!staticProps.editMode">{{ answerLabelFor(question.key) }}</span>
+                                <select v-else v-model="form.participationOptions[question.key]">
+                                    <option value="">— keine —</option>
+                                    <option v-for="option in question.options" :key="option.value"
+                                            :value="option.value">
+                                        {{ option.label }}
+                                    </option>
+                                </select>
+                            </td>
+                        </tr>
+                    </table>
+                </template>
+            </div>
+            <div>
+                <template v-if="eventAddons.length > 0">
+                    <h3>Zusatzoptionen</h3>
+                    <table>
+                        <tr v-for="addon in eventAddons" :key="addon.key">
+                            <th>{{ addon.title }}</th>
+                            <td>
+                                <span v-if="!staticProps.editMode">{{ isAddonSelected(addon.key) ? 'Ja' : '—' }}</span>
+                                <input v-else type="checkbox" v-model="form.selectedAddons[addon.key]"/>
+                            </td>
+                        </tr>
+                    </table>
+                </template>
+            </div>
+        </div>
     </div>
 
     <button v-if="!staticProps.editMode" class="button" @click="enableEditMode">Bearbeiten</button>
@@ -395,6 +507,12 @@ function saveParticipant() {
 
     <button v-if="!props.participant.unregistered" class="button" @click="paymentComplete(props.participant)">Zahlung vollständig</button>
     <button v-if="!props.participant.unregistered" class="button" @click="markCocExisting(props.participant)">eFZ liegt vor</button>
+    <button
+        v-if="!props.participant.unregistered && hasAmount"
+        class="button"
+        :disabled="creatingInvoice"
+        @click="downloadInvoice"
+    >{{ creatingInvoice ? 'Wird erstellt…' : 'Rechnung erstellen' }}</button>
     <button v-if="!props.participant.unregistered" class="button" @click="cancelParticipation(props.participant)">Abmelden</button>
     <button class="button" @click="close">Schließen</button>
 
@@ -407,6 +525,10 @@ function saveParticipant() {
     gap: 20px;
 }
 
+.participationData table tr th {
+    width: 200px;
+}
+
 .participationData div {
     flex: 1;
     vertical-align: top;
@@ -427,4 +549,8 @@ textarea {
 select {
     width: 262px;
 }
+
+.retention-note {
+    color: #8a6d00;
+}
 </style>

app/Domains/Event/Views/Partials/ParticipantsByAddon.vue

@@ -0,0 +1,67 @@
+<script setup>
+import {computed, inject} from "vue";
+import ParticipantsList from "./ParticipantsList.vue";
+
+const props = defineProps({
+    data: {
+        type: Object,
+        default: () => ({participants: {}, event: {}, listType: ''}),
+    },
+});
+
+// Von TabbedPage bereitgestellt: erlaubt den Sprung zum Übersicht-Tab (Index 0), wo die
+// Zusatzoptionen konfiguriert werden.
+const selectTab = inject('selectTab', null);
+
+const hasAddons = computed(() => (props.data?.event?.addons?.length ?? 0) > 0);
+
+function goToOverview() {
+    if (selectTab) {
+        selectTab(0);
+    }
+}
+</script>
+
+<template>
+    <ParticipantsList v-if="hasAddons" :data="data" :show-group-mail="false"/>
+
+    <div v-else class="no-addons">
+        <h3>Keine Zusatzoptionen angelegt</h3>
+        <p>
+            Für diese Veranstaltung sind noch keine Zusatzoptionen angelegt. Sobald du unter
+            <strong>Übersicht → Zusatzoptionen</strong> Zusätze definierst, werden die Teilnehmenden hier nach
+            ihren gebuchten Zusätzen gruppiert.
+        </p>
+        <button v-if="selectTab" type="button" class="button" @click="goToOverview">
+            Zu den Zusatzoptionen
+        </button>
+    </div>
+</template>
+
+<style scoped>
+.no-addons {
+    max-width: 640px;
+    margin: 20px auto;
+    padding: 24px;
+    background: #f8fafc;
+    border: 1px solid #e5e7eb;
+    border-radius: 10px;
+    text-align: center;
+}
+
+.no-addons p {
+    color: #4b5563;
+    line-height: 1.6;
+}
+
+.button {
+    margin-top: 12px;
+    padding: 8px 18px;
+    background: #2563eb;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    cursor: pointer;
+}
+</style>

app/Domains/Event/Views/Partials/ParticipantsByOption.vue

@@ -0,0 +1,67 @@
+<script setup>
+import {computed, inject} from "vue";
+import ParticipantsList from "./ParticipantsList.vue";
+
+const props = defineProps({
+    data: {
+        type: Object,
+        default: () => ({participants: {}, event: {}, listType: ''}),
+    },
+});
+
+// Von TabbedPage bereitgestellt: erlaubt den Sprung zum Übersicht-Tab (Index 0), wo die
+// Teilnahmeoptionen konfiguriert werden.
+const selectTab = inject('selectTab', null);
+
+const hasOptions = computed(() => (props.data?.event?.participationOptions?.length ?? 0) > 0);
+
+function goToOverview() {
+    if (selectTab) {
+        selectTab(0);
+    }
+}
+</script>
+
+<template>
+    <ParticipantsList v-if="hasOptions" :data="data" :show-group-mail="false"/>
+
+    <div v-else class="no-options">
+        <h3>Keine Teilnahmeoptionen angelegt</h3>
+        <p>
+            Für diese Veranstaltung sind noch keine Teilnahmeoptionen angelegt. Sobald du unter
+            <strong>Übersicht → Teilnahmeoptionen</strong> Fragen definierst, werden die Teilnehmenden hier nach
+            ihrer Auswahl gruppiert.
+        </p>
+        <button v-if="selectTab" type="button" class="button" @click="goToOverview">
+            Zu den Teilnahmeoptionen
+        </button>
+    </div>
+</template>
+
+<style scoped>
+.no-options {
+    max-width: 640px;
+    margin: 20px auto;
+    padding: 24px;
+    background: #f8fafc;
+    border: 1px solid #e5e7eb;
+    border-radius: 10px;
+    text-align: center;
+}
+
+.no-options p {
+    color: #4b5563;
+    line-height: 1.6;
+}
+
+.button {
+    margin-top: 12px;
+    padding: 8px 18px;
+    background: #2563eb;
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    cursor: pointer;
+}
+</style>

app/Domains/Event/Views/Partials/ParticipantsList.vue

@@ -9,6 +9,8 @@ import {format} from "date-fns";
 import AmountInput from "../../../../Views/Components/AmountInput.vue";
 import FullScreenModal from "../../../../Views/Components/FullScreenModal.vue";
 import DialableTelephoneNumber from "../../../../Views/Components/DialableTelephoneNumber.vue";
+import ErrorText from "../../../../Views/Components/ErrorText.vue";
+import IbanInput from "../../../../Views/Components/IbanInput.vue";
 
 const props = defineProps({
     data: {
@@ -20,11 +22,16 @@ const props = defineProps({
             listType: '',
         }),
     },
+    // Steuert, ob je Gruppe der „E-Mail an Gruppe senden"-Button angezeigt wird.
+    showGroupMail: {
+        type: Boolean,
+        default: true,
+    },
 });
 
 const today = format(new Date(), "yyyy-MM-dd");
 
-const { request } = useAjax();
+const { request, download } = useAjax();
 
 const searchTerms = reactive({});
 const selectedStatuses = reactive({});
@@ -39,6 +46,86 @@ const mailCompose = ref(false);
 
 const openCancelDialog = ref(false);
 const openPartialPaymentDialogSwitch = ref(false);
+const openRefundDialogSwitch = ref(false);
+
+// Der Erstattungsdialog. `captureMode` steuert den Weg: 'participant' schickt dem Teili einen Link, über
+// den er seine Bankverbindung selbst einträgt; 'management' heißt, sie liegt der Aktionsleitung bereits
+// vor -- dann wird die Erstattung sofort eingereicht.
+const refundForm = reactive({
+    amount: '', reason: '', reasonNote: '',
+    captureMode: 'participant', accountOwner: '', accountIban: '',
+    retentionReason: '', retentionReasonNote: '',
+});
+const refundErrors = reactive({amount: '', reason: '', reasonNote: '', accountOwner: '', accountIban: ''});
+const refundReasons = ref([]);
+const retentionReasons = ref([]);
+const refundSaving = ref(false);
+
+const selectedRefundReason = computed(
+    () => refundReasons.value.find(r => r.value === refundForm.reason) ?? null
+);
+
+const selectedRetentionReason = computed(
+    () => retentionReasons.value.find(r => r.value === refundForm.retentionReason) ?? null
+);
+
+/** Was nach der Erstattung beim Verband bleibt -- die Grundlage für den Einbehaltungsblock. */
+const retainedAmount = computed(() => {
+    const paid = Number(showParticipant.value?.amountPaidValue ?? 0);
+    const refunded = Number((refundForm.amount ?? '').replace(',', '.'));
+
+    if (!Number.isFinite(refunded)) {
+        return 0;
+    }
+
+    const remaining = Math.round((paid - refunded) * 100) / 100;
+
+    return remaining > 0.005 ? remaining : 0;
+});
+
+const hasRetention = computed(() => retainedAmount.value > 0);
+
+const retainedAmountReadable = computed(
+    () => retainedAmount.value.toFixed(2).replace('.', ',') + ' Euro'
+);
+
+/**
+ * Ob abgesendet werden kann. Der Knopf erscheint erst dann -- was noch fehlt, soll die Aktionsleitung
+ * sehen, bevor sie klickt, statt danach eine Fehlermeldung zu lesen.
+ */
+const refundFormComplete = computed(() => {
+    const amount = Number((refundForm.amount ?? '').replace(',', '.'));
+    const paid = Number(showParticipant.value?.amountPaidValue ?? 0);
+
+    if (!refundForm.amount || !(amount > 0) || amount > paid + 0.005) {
+        return false;
+    }
+
+    if (!refundForm.reason) {
+        return false;
+    }
+
+    if (selectedRefundReason.value?.requiresNote && !refundForm.reasonNote.trim()) {
+        return false;
+    }
+
+    // Bleibt etwas beim Verband, muss begründet sein, warum.
+    if (hasRetention.value) {
+        if (!refundForm.retentionReason) {
+            return false;
+        }
+
+        if (selectedRetentionReason.value?.requiresNote && !refundForm.retentionReasonNote.trim()) {
+            return false;
+        }
+    }
+
+    if (refundForm.captureMode === 'management') {
+        return refundForm.accountOwner.trim() !== '' && refundForm.accountIban.trim() !== '';
+    }
+
+    return true;
+});
 
 defineEmits(['showParticipantDetails', 'markCocExisting', 'paymentComplete'])
 
@@ -287,6 +374,136 @@ async function execPartialPayment() {
     openPartialPaymentDialogSwitch.value = false;
 }
 
+/**
+ * Erstattung freigeben.
+ *
+ * Der Betrag ist mit dem vor, was der Teili gezahlt hat -- das ist der Regelfall; Abzüge trägt die
+ * Aktionsleitung von Hand ein.
+ */
+async function openRefundDialog(participant) {
+    showParticipant.value = participant;
+
+    refundForm.amount = participant.amountPaid?.short ?? '';
+    refundForm.reason = '';
+    refundForm.reasonNote = '';
+    // Vorgabe ist der übliche Weg über den Teili.
+    refundForm.captureMode = 'participant';
+    refundForm.accountOwner = '';
+    refundForm.accountIban = '';
+    refundForm.retentionReason = '';
+    refundForm.retentionReasonNote = '';
+
+    Object.keys(refundErrors).forEach(key => refundErrors[key] = '');
+
+    if (refundReasons.value.length === 0) {
+        const reasons = await request('/api/v1/core/retrieve-refund-reasons', {method: 'GET'});
+        refundReasons.value = reasons ?? [];
+    }
+
+    if (retentionReasons.value.length === 0) {
+        const reasons = await request('/api/v1/core/retrieve-retention-reasons', {method: 'GET'});
+        retentionReasons.value = reasons ?? [];
+    }
+
+    openRefundDialogSwitch.value = true;
+}
+
+function validateRefund() {
+    const amount = Number((refundForm.amount ?? '').replace(',', '.'));
+    const paid = Number(showParticipant.value?.amountPaidValue ?? 0);
+
+    Object.keys(refundErrors).forEach(key => refundErrors[key] = '');
+
+    if (!refundForm.amount || !(amount > 0)) {
+        refundErrors.amount = 'Bitte gib einen Betrag größer als 0 ein.';
+    } else if (amount > paid + 0.005) {
+        refundErrors.amount = 'Mehr als der gezahlte Beitrag kann nicht erstattet werden.';
+    }
+
+    if (!refundForm.reason) {
+        refundErrors.reason = 'Bitte wähle einen Grund aus.';
+    } else if (selectedRefundReason.value?.requiresNote && !refundForm.reasonNote.trim()) {
+        refundErrors.reasonNote = 'Bitte erläutere den Grund.';
+    }
+
+    // Beim Direktweg wird sofort eingereicht -- danach gibt es keine Gelegenheit mehr zu berichtigen.
+    // Ob die IBAN wirklich stimmt, prüft der Server mit Prüfziffer und länderabhängiger Länge.
+    if (refundForm.captureMode === 'management') {
+        if (!refundForm.accountOwner.trim()) {
+            refundErrors.accountOwner = 'Bitte gib an, wem das Konto gehört.';
+        }
+
+        if (!refundForm.accountIban.trim()) {
+            refundErrors.accountIban = 'Bitte gib die IBAN des Kontos ein.';
+        }
+    }
+
+    return Object.values(refundErrors).every(message => !message);
+}
+
+async function execRefund() {
+    if (!validateRefund() || refundSaving.value) {
+        return;
+    }
+
+    refundSaving.value = true;
+
+    try {
+        const data = await request('/api/v1/participant-refund/' + showParticipant.value.identifier + '/release', {
+            method: "POST",
+            body: {
+                amount: refundForm.amount,
+                reason: refundForm.reason,
+                reasonNote: refundForm.reasonNote,
+                // Leer beim Weg über den Teili -- dann verschickt der Server nur den Link.
+                accountOwner: refundForm.captureMode === 'management' ? refundForm.accountOwner : '',
+                accountIban: refundForm.captureMode === 'management' ? refundForm.accountIban : '',
+                // Leer bei voller Erstattung -- dann gibt es nichts zu begründen.
+                retentionReason: hasRetention.value ? refundForm.retentionReason : '',
+                retentionReasonNote: hasRetention.value ? refundForm.retentionReasonNote : '',
+            },
+        });
+
+        if (data?.status === 'success') {
+            toast.success(data.message);
+            // Reaktiv statt per getElementById: die Meta-Zeile hängt am Vorgang und wechselt mit ihm.
+            // Beim Direktweg steht dort sofort "Erstattet" samt Abrechnungsnummer.
+            showParticipant.value.refund = data.refund;
+            // Der gezahlte Beitrag wird beim Einreichen auf 0 gesetzt -- sonst zeigte die Zeile weiter
+            // den alten Stand, bis jemand neu lädt.
+            if (data.refund?.status === 'accepted') {
+                showParticipant.value.amountPaidValue = 0;
+            }
+            openRefundDialogSwitch.value = false;
+        } else {
+            toast.error(data?.message ?? 'Die Erstattung konnte nicht freigegeben werden.');
+        }
+    } finally {
+        refundSaving.value = false;
+    }
+}
+
+async function execCancelRefund(participant) {
+    const data = await request('/api/v1/participant-refund/' + participant.refund.token + '/cancel', {
+        method: "POST",
+    });
+
+    if (data?.status === 'success') {
+        toast.success(data.message);
+        participant.refund = null;
+    } else {
+        toast.error(data?.message ?? 'Die Erstattung konnte nicht abgebrochen werden.');
+    }
+}
+
+async function downloadRefundDocument(participant) {
+    const ok = await download('/api/v1/participant-refund/' + participant.refund.token + '/document');
+
+    if (!ok) {
+        toast.error('Der Beleg konnte nicht erstellt werden.');
+    }
+}
+
 const mailToType = ref('')
 const recipientIdentifier = ref('')
 
@@ -339,6 +556,15 @@ function mailToGroup(groupKey) {
                         <td class="pl-amount" :id="'participant-' + participant.identifier +'-payment'" :class="participant.amount_left_value != 0 && !participant.unregistered ? 'not-paid' : ''">
                             Gezahlt: <label :id="'participant-' + participant.identifier + '-paid'">{{ participant?.amountPaid.readable }}</label> /<br />
                             Gesamt: <label :id="'participant-' + participant.identifier + '-expected'">{{ participant?.amountExpected.readable }}</label>
+
+                            <!-- Warum ein Teil des Beitrags beim Verband geblieben ist. -->
+                            <span v-if="participant.refund?.hasRetention" class="retention-note">
+                                Einbehalten: {{ participant.refund.retainedAmount }}<br />
+                                {{ participant.refund.retentionReasonLabel }}<template
+                                    v-if="participant.refund.retentionReasonNote"
+                                > &ndash; {{ participant.refund.retentionReasonNote }}</template>
+                            </span>
+
                             <br /><br />
                             <span v-if="participant.amount_left_value != 0 && !participant.unregistered" :id="'participant-' + participant.identifier + '-actions'">
                                 <span class="link" style="font-size:10pt;" @click="paymentComplete(participant)">Zahlung buchen</span> &nbsp;
@@ -390,6 +616,30 @@ function mailToGroup(groupKey) {
                             <span class="link">E-Mail senden</span> |
                             <span  @click="openCancelParticipationDialog(participant)" v-if="!participant.unregistered" class="link" style="color: #da7070;">Abmelden</span>
                             <span v-else class="link" @click="execResignonParticipant(participant)" style="color: #3cb62e;">Wieder anmelden</span>
+
+                            <!-- Erstattung: erst der Einstieg, danach der Zustand des Vorgangs. -->
+                            <template v-if="participant.unregistered">
+                                <span
+                                    v-if="!participant.refund && Number(participant.amountPaidValue ?? 0) > 0"
+                                    class="link"
+                                    style="color: #da7070;"
+                                    @click="openRefundDialog(participant)"
+                                > | Beitrag erstatten</span>
+
+                                <template v-else-if="participant.refund?.status === 'pending'">
+                                    | <strong>Erstattung offen:</strong> {{ participant.refund.amount }},
+                                    wartet auf Bankverbindung
+                                    <span class="link" style="color: #da7070;" @click="execCancelRefund(participant)">Abbrechen</span>
+                                </template>
+
+                                <template v-else-if="participant.refund?.status === 'accepted'">
+                                    | <strong>Erstattet:</strong> {{ participant.refund.amount }}
+                                    <template v-if="participant.refund.invoiceNumber">
+                                        &middot; Abrechnung {{ participant.refund.invoiceNumber }}
+                                    </template>
+                                    <span class="link" @click="downloadRefundDocument(participant)">Beleg</span>
+                                </template>
+                            </template>
                         </td>
                     </tr>
                 </template>
@@ -404,7 +654,8 @@ function mailToGroup(groupKey) {
                         27 Jahre und älter: <strong>{{ getAgeCounts(participants)['27+'] ?? 0 }}</strong>
                     </td>
                     <td class="pl-summary-action">
-                        <input type="button" class="button" @click="mailToGroup(groupKey)" value="E-Mail an Gruppe senden" />
+                        <input v-if="showGroupMail" type="button" class="button" @click="mailToGroup(groupKey)"
+                               value="E-Mail an Gruppe senden"/>
                     </td>
                 </tr>
                 </tbody>
@@ -454,6 +705,124 @@ function mailToGroup(groupKey) {
         <button class="button" @click="execPartialPayment()">Teilbetrag buchen</button>
     </Modal>
 
+    <Modal
+        :show="openRefundDialogSwitch"
+        title="Beitrag erstatten"
+        width="480px"
+        @close="openRefundDialogSwitch = false"
+    >
+        <p class="refund-intro">
+            {{ showParticipant?.fullname }} hat
+            <strong>{{ showParticipant?.amountPaid?.readable }}</strong> gezahlt.
+        </p>
+
+        <div class="refund-field">
+            <label for="refund_amount">Zu erstattender Betrag</label>
+            <div>
+                <AmountInput id="refund_amount" v-model="refundForm.amount" style="width: 100px !important;" /> Euro
+            </div>
+            <ErrorText :message="refundErrors.amount" />
+        </div>
+
+        <div class="refund-field">
+            <label for="refund_reason">Grund</label>
+            <select id="refund_reason" v-model="refundForm.reason" class="form-input">
+                <option value="">Bitte auswählen …</option>
+                <option v-for="reason in refundReasons" :key="reason.value" :value="reason.value">
+                    {{ reason.label }}
+                </option>
+            </select>
+            <ErrorText :message="refundErrors.reason" />
+        </div>
+
+        <div v-if="selectedRefundReason?.requiresNote" class="refund-field">
+            <label for="refund_reason_note">Erläuterung</label>
+            <textarea id="refund_reason_note" v-model="refundForm.reasonNote" class="form-input" rows="3"></textarea>
+            <ErrorText :message="refundErrors.reasonNote" />
+        </div>
+
+        <!--
+            Bleibt ein Teil beim Verband, muss begründet sein, warum -- ein einbehaltener Betrag ohne
+            Grund ist in der Buchhaltung nicht haltbar. Bei voller Erstattung gibt es nichts zu zeigen.
+        -->
+        <template v-if="hasRetention">
+            <p class="refund-hint">
+                <strong>{{ retainedAmountReadable }}</strong> verbleiben beim Verband.
+            </p>
+
+            <div class="refund-field">
+                <label for="refund_retention_reason">Grund der Einbehaltung</label>
+                <select id="refund_retention_reason" v-model="refundForm.retentionReason" class="form-input">
+                    <option value="">Bitte auswählen …</option>
+                    <option v-for="reason in retentionReasons" :key="reason.value" :value="reason.value">
+                        {{ reason.label }}
+                    </option>
+                </select>
+            </div>
+
+            <div v-if="selectedRetentionReason?.requiresNote" class="refund-field">
+                <label for="refund_retention_note">Erläuterung zur Einbehaltung</label>
+                <textarea
+                    id="refund_retention_note"
+                    v-model="refundForm.retentionReasonNote"
+                    class="form-input"
+                    rows="3"
+                ></textarea>
+            </div>
+        </template>
+
+        <!--
+            Liegt die Bankverbindung schon vor, entfällt der Umweg über den Teili: die Erstattung wird
+            sofort eingereicht. Er bekommt den Beleg trotzdem.
+        -->
+        <div class="refund-field">
+            <label class="refund-choice">
+                <input type="radio" value="participant" v-model="refundForm.captureMode" />
+                Teilnehmer*in trägt die Bankverbindung selbst ein
+            </label>
+            <label class="refund-choice">
+                <input type="radio" value="management" v-model="refundForm.captureMode" />
+                Bankverbindung liegt mir vor
+            </label>
+        </div>
+
+        <template v-if="refundForm.captureMode === 'management'">
+            <div class="refund-field">
+                <label for="refund_account_owner">Kontoinhaber*in</label>
+                <input
+                    id="refund_account_owner"
+                    v-model="refundForm.accountOwner"
+                    type="text"
+                    class="form-input"
+                />
+                <ErrorText :message="refundErrors.accountOwner" />
+            </div>
+
+            <div class="refund-field">
+                <label for="refund_account_iban">IBAN</label>
+                <IbanInput id="refund_account_iban" v-model="refundForm.accountIban" class="form-input" />
+                <ErrorText :message="refundErrors.accountIban" />
+            </div>
+
+            <p class="refund-hint">
+                Die Erstattung wird sofort als Abrechnung eingereicht. Der Teili erhält den Beleg per
+                E-Mail und kann die Angaben prüfen.
+            </p>
+        </template>
+
+        <!-- Erscheint erst, wenn alles ausgefüllt ist; während des Speicherns gesperrt statt weg. -->
+        <button
+            v-if="refundFormComplete"
+            class="button"
+            :disabled="refundSaving"
+            @click="execRefund()"
+        >
+            <template v-if="refundSaving">Wird gespeichert…</template>
+            <template v-else-if="refundForm.captureMode === 'management'">Erstattung einreichen</template>
+            <template v-else>Erstattung freigeben</template>
+        </button>
+    </Modal>
+
     <FullScreenModal
         :show="mailCompose"
         title="E-Mail senden"
@@ -467,6 +836,58 @@ function mailToGroup(groupKey) {
 </template>
 
 <style scoped>
+.refund-intro {
+    margin-bottom: 16px;
+    font-size: 0.9rem;
+    color: #4b5563;
+}
+
+.refund-field {
+    margin-bottom: 14px;
+}
+
+.refund-field label {
+    display: block;
+    margin-bottom: 4px;
+    font-size: 0.9rem;
+    color: #4b5563;
+}
+
+.refund-field select,
+.refund-field textarea,
+.refund-field .form-input {
+    width: 100%;
+}
+
+.refund-choice {
+    display: block;
+    margin-bottom: 6px;
+    font-size: 0.9rem;
+    color: #1a1a1a;
+    cursor: pointer;
+}
+
+.refund-choice input {
+    margin-right: 6px;
+}
+
+.retention-note {
+    display: block;
+    margin-top: 6px;
+    font-size: 10pt;
+    color: #ca5a0a;
+    line-height: 1.4;
+}
+
+.refund-hint {
+    margin-bottom: 14px;
+    padding: 8px 10px;
+    border-left: 3px solid #f5c400;
+    background-color: #fffef5;
+    font-size: 0.85rem;
+    color: #4b5563;
+}
+
 .participants-table {
     width: 95%;
     margin: 20px auto;

app/Domains/Event/Views/Partials/ParticipationOptions.vue

@@ -0,0 +1,182 @@
+<script setup>
+import {ref} from "vue";
+import {toast} from "vue3-toastify";
+import {request} from "../../../../../resources/js/components/HttpClient.js";
+
+const emit = defineEmits(['close'])
+
+const props = defineProps({
+    event: Object,
+})
+
+// Fragen-Definition dieses Events: [ { key, label, options: [ { value, label } ] } ].
+// key/value bleiben für bestehende Einträge erhalten (Bestandsschutz für bereits gespeicherte Antworten);
+// neue Einträge bekommen serverseitig beim Speichern einen stabilen Slug.
+const questions = ref((props.event.participationOptions ?? []).map(q => ({
+    key: q.key ?? '',
+    title: q.title ?? '',
+    label: q.label ?? '',
+    options: (q.options ?? []).map(o => ({value: o.value ?? '', label: o.label ?? ''})),
+})))
+
+function addQuestion() {
+    questions.value.push({key: '', title: '', label: '', options: [{value: '', label: ''}, {value: '', label: ''}]})
+}
+
+function removeQuestion(index) {
+    questions.value.splice(index, 1)
+}
+
+function addOption(question) {
+    question.options.push({value: '', label: ''})
+}
+
+function removeOption(question, index) {
+    question.options.splice(index, 1)
+}
+
+function validate() {
+    for (const question of questions.value) {
+        if (question.title.trim() === '') {
+            toast.error('Bitte für jede Frage einen Titel angeben.')
+            return false
+        }
+
+        const validOptions = question.options.filter(o => o.label.trim() !== '')
+        if (validOptions.length < 1) {
+            toast.error('Jede Frage braucht mindestens eine Auswahlmöglichkeit.')
+            return false
+        }
+    }
+
+    return true
+}
+
+async function save() {
+    if (!validate()) {
+        return
+    }
+
+    const response = await request('/api/v1/event/details/' + props.event.id + '/participation-options', {
+        method: 'POST',
+        body: {
+            questions: questions.value,
+        }
+    })
+
+    if (response.status !== 'success') {
+        toast.error(response.message ?? 'Die Teilnahmeoptionen konnten nicht gespeichert werden.')
+        return
+    }
+
+    toast.success('Die Teilnahmeoptionen wurden gespeichert')
+    emit('close')
+}
+</script>
+
+<template>
+    <div class="participation-options">
+        <h3>Teilnahmeoptionen</h3>
+        <p style="color: #6b7280; font-size: 0.9rem;">
+            Pflicht-Auswahlfragen für die Anmeldung (z. B. Kurs oder Stufe). Je Frage ist genau eine Option wählbar.
+            Ohne Fragen wird dieser Schritt in der Anmeldung übersprungen.
+        </p>
+
+        <div v-for="(question, qIndex) in questions" :key="qIndex" class="question-card">
+            <div class="question-head">
+                <div class="question-fields">
+                    <label class="field-label">Titel (Überschrift / Feldbeschriftung)</label>
+                    <input
+                        type="text"
+                        v-model="question.title"
+                        class="width-full"
+                        placeholder="Titel, z. B. „Kurs“"
+                    />
+
+                    <label class="field-label">Frage / Erklärtext (optional)</label>
+                    <input
+                        type="text"
+                        v-model="question.label"
+                        class="width-full"
+                        placeholder="z. B. „Welchen Kurs möchtest du belegen?“"
+                    />
+                </div>
+                <label class="link remove-link" @click="removeQuestion(qIndex)">Frage entfernen</label>
+            </div>
+
+            <div class="options">
+                <div v-for="(option, oIndex) in question.options" :key="oIndex" class="option-row">
+                    <input
+                        type="text"
+                        v-model="option.label"
+                        class="width-full"
+                        placeholder="Auswahlmöglichkeit"
+                    />
+                    <label class="link remove-link" @click="removeOption(question, oIndex)">✕</label>
+                </div>
+                <label class="link" @click="addOption(question)">+ Option hinzufügen</label>
+            </div>
+        </div>
+
+        <div style="margin-top: 16px;">
+            <label class="link" @click="addQuestion">+ Frage hinzufügen</label>
+        </div>
+
+        <div style="margin-top: 24px;">
+            <input type="button" value="Speichern" @click="save"/>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+.question-card {
+    margin-top: 16px;
+    padding: 14px;
+    background: #f8fafc;
+    border: 1px solid #e5e7eb;
+    border-radius: 10px;
+}
+
+.question-head {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+}
+
+.question-fields {
+    flex: 1;
+}
+
+.field-label {
+    display: block;
+    font-size: 0.78rem;
+    color: #6b7280;
+    margin: 6px 0 2px;
+}
+
+.question-fields .field-label:first-child {
+    margin-top: 0;
+}
+
+.options {
+    margin-top: 12px;
+    padding-left: 12px;
+}
+
+.option-row {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 8px;
+}
+
+.width-full {
+    width: 100%;
+}
+
+.remove-link {
+    white-space: nowrap;
+    color: #ef4444;
+    font-size: 0.85rem;
+}
+</style>

app/Domains/Event/Views/Partials/ParticipationSummary.vue

@@ -68,6 +68,17 @@ const props = defineProps({
                         </td>
                     </tr>
 
+                    <!--
+                        Beiträge, die trotz Abmeldung beim Verband geblieben sind. Eigene Zeile, weil die
+                        Zeilen darüber nur aktive Anmeldungen führen.
+                    -->
+                    <tr v-if="props.event.retainedFromUnregistered.value > 0">
+                        <th style="padding-bottom: 20px" colspan="2">Einbehalten von Abmeldungen</th>
+                        <td style="padding-bottom: 20px" colspan="2">
+                            {{ props.event.retainedFromUnregistered.readable }}
+                        </td>
+                    </tr>
+
                     <tr>
                         <th colspan="2" style="border-width: 1px; border-top-style: solid">Gesamt</th>
                         <td style="font-weight: bold; border-width: 1px; border-top-style: solid">

app/Domains/Event/Views/Partials/SignUpForm/SignupForm.vue

@@ -6,6 +6,7 @@ import StepPersonalData from './steps/StepPersonalData.vue'
 import StepRegistrationMode from './steps/StepRegistrationMode.vue'
 import StepArrival from './steps/StepArrival.vue'
 import StepAddons from './steps/StepAddons.vue'
+import StepParticipationOptions from './steps/StepParticipationOptions.vue'
 import StepPhotoPermissions from './steps/StepPhotoPermissions.vue'
 import StepAllergies from './steps/StepAllergies.vue'
 import StepPaymentMethod from './steps/StepPaymentMethod.vue'
@@ -23,7 +24,8 @@ const emit = defineEmits(['registrationDone'])
 
 const {
     currentStep, goToStep, formData, selectedAddons,
-    submit, submitting, submitResult, summaryLoading, summaryAmount, summaryAmountValue
+    submit, submitting, submitResult, summaryLoading, summaryAmount, summaryAmountValue,
+    summaryBaseAmount, summaryAddonLines
 } = useSignupForm(props.event, props.participantData)
 
 const steps = [
@@ -33,10 +35,11 @@ const steps = [
     { step: 4, label: 'An-/Abreise' },
     { step: 5, label: 'Teilnahmegruppe' },
     { step: 6, label: 'Zusatzoptionen' },
-    { step: 7, label: 'Fotoerlaubnis' },
+    {step: 7, label: 'Teilnahmeoptionen'},
-    { step: 8, label: 'Allergien' },
+    {step: 8, label: 'Fotoerlaubnis'},
-    {step: 9, label: 'Zahlungsart'},
+    {step: 9, label: 'Allergien'},
-    {step: 10, label: 'Zusammenfassung'},
+    {step: 10, label: 'Zahlungsart'},
+    {step: 11, label: 'Zusammenfassung'},
 ]
 </script>
 
@@ -93,14 +96,20 @@ const steps = [
                 <StepArrival        v-if="currentStep === 4" :formData="formData" :event="event" @next="goToStep" @back="goToStep" />
                 <StepRegistrationMode v-if="currentStep === 5" :formData="formData" :event="event" @next="goToStep" @back="goToStep" />
                 <StepAddons         v-if="currentStep === 6" :formData="formData" :event="event" :selectedAddons="selectedAddons" @next="goToStep" @back="goToStep" />
-                <StepPhotoPermissions v-if="currentStep === 7" :formData="formData" :event="event" @next="goToStep" @back="goToStep" />
+                <StepParticipationOptions v-if="currentStep === 7" :formData="formData" :event="event" @next="goToStep"
-                <StepAllergies      v-if="currentStep === 8" :formData="formData" :event="event" @next="goToStep" @back="goToStep" />
+                                          @back="goToStep"/>
-                <StepPaymentMethod v-if="currentStep === 9" :formData="formData" :event="event" @next="goToStep"
+                <StepPhotoPermissions v-if="currentStep === 8" :formData="formData" :event="event" @next="goToStep"
+                                      @back="goToStep"/>
+                <StepAllergies v-if="currentStep === 9" :formData="formData" :event="event" @next="goToStep"
+                               @back="goToStep"/>
+                <StepPaymentMethod v-if="currentStep === 10" :formData="formData" :event="event" @next="goToStep"
                                    @back="goToStep"/>
                 <StepSummary
-                    v-if="currentStep === 10"
+                    v-if="currentStep === 11"
                     :formData="formData"
                     :event="event"
+                    :summaryBaseAmount="summaryBaseAmount"
+                    :summaryAddonLines="summaryAddonLines"
                     :summaryAmount="summaryAmount"
                     :summaryAmountValue="summaryAmountValue"
                     :summaryLoading="summaryLoading"

app/Domains/Event/Views/Partials/SignUpForm/composables/stepFlow.js

@@ -0,0 +1,45 @@
+// Zentrale Schrittreihenfolge des Anmelde-Wizards. Einige Schritte sind optional und werden
+// übersprungen, wenn sie für das Event nicht zutreffen (Zusatzoptionen, Teilnahmeoptionen).
+// Der Zahlungsschritt wird separat in useSignupForm anhand des berechneten Betrags übersprungen.
+export const STEP_AGE = 1
+export const STEP_CONTACT = 2
+export const STEP_PERSONAL = 3
+export const STEP_ARRIVAL = 4
+export const STEP_REGISTRATION = 5
+export const STEP_ADDONS = 6
+export const STEP_PARTICIPATION_OPTIONS = 7
+export const STEP_PHOTO = 8
+export const STEP_ALLERGIES = 9
+export const STEP_PAYMENT = 10
+export const STEP_SUMMARY = 11
+
+// Ob ein (optionaler) Schritt für dieses Event angezeigt wird.
+export function stepVisible(event, step) {
+    if (step === STEP_ADDONS) {
+        return (event.addons?.length ?? 0) > 0
+    }
+
+    if (step === STEP_PARTICIPATION_OPTIONS) {
+        return (event.participationOptions?.length ?? 0) > 0
+    }
+
+    return true
+}
+
+// Nächster sichtbarer Schritt nach `step` (überspringt ausgeblendete optionale Schritte).
+export function nextVisibleFrom(event, step) {
+    let candidate = step + 1
+    while (candidate < STEP_SUMMARY && !stepVisible(event, candidate)) {
+        candidate++
+    }
+    return candidate
+}
+
+// Vorheriger sichtbarer Schritt vor `step`.
+export function prevVisibleFrom(event, step) {
+    let candidate = step - 1
+    while (candidate > STEP_AGE && !stepVisible(event, candidate)) {
+        candidate--
+    }
+    return candidate
+}

app/Domains/Event/Views/Partials/SignUpForm/composables/useSignupForm.js

@@ -1,5 +1,6 @@
 import {reactive, ref} from 'vue'
 import axios from 'axios'
+import {STEP_PAYMENT, STEP_SUMMARY} from './stepFlow.js'
 
 export function useSignupForm(event, participantData) {
     const currentStep = ref(1)
@@ -16,6 +17,8 @@ export function useSignupForm(event, participantData) {
         eatingHabit: 'EATING_HABIT_VEGAN',
         paymentMethod: activeMethods.length === 1 ? activeMethods[0].slug : null,
         paymentOptions: {},
+        // Antworten auf die event-spezifischen Teilnahmeoptionen: { [question.key]: option.value }
+        participationOptions: {},
         userId: participantData.id,
         eventId: event.id,
         vorname: participantData.firstname ?? '',
@@ -57,6 +60,8 @@ export function useSignupForm(event, participantData) {
 
     const summaryAmount = ref('')
     const summaryAmountValue = ref(0)
+    const summaryBaseAmount = ref('')
+    const summaryAddonLines = ref([])
 
     const fetchAmount = async () => {
         summaryLoading.value = true
@@ -74,15 +79,13 @@ export function useSignupForm(event, participantData) {
             })
             summaryAmount.value = res.data.amount
             summaryAmountValue.value = Number(res.data.amountValue ?? 0)
+            summaryBaseAmount.value = res.data.baseAmount ?? ''
+            summaryAddonLines.value = res.data.addons ?? []
         } finally {
             summaryLoading.value = false
         }
     }
 
-    // Steps: ... 8 Allergien, 9 Zahlungsart, 10 Zusammenfassung.
-    const STEP_PAYMENT = 9
-    const STEP_SUMMARY = 10
-
     const goToStep = async (step) => {
         if (step === STEP_PAYMENT) {
             // Betrag ermitteln: Bei 0 € wird die Zahlungsart-Auswahl übersprungen.
@@ -129,6 +132,8 @@ export function useSignupForm(event, participantData) {
         submitResult,
         summaryLoading,
         summaryAmount,
-        summaryAmountValue
+        summaryAmountValue,
+        summaryBaseAmount,
+        summaryAddonLines
     }
 }

app/Domains/Event/Views/Partials/SignUpForm/steps/StepAddons.vue

@@ -1,6 +1,10 @@
 <script setup>
+import {nextVisibleFrom, STEP_ADDONS} from "../composables/stepFlow.js";
+
 const props = defineProps({ formData: Object, event: Object, selectedAddons: Object })
 const emit = defineEmits(['next', 'back'])
+
+const next = () => emit('next', nextVisibleFrom(props.event, STEP_ADDONS))
 </script>
 
 <template>
@@ -25,13 +29,21 @@ const emit = defineEmits(['next', 'back'])
         <!-- Addons -->
         <div v-if="event.addons?.length > 0">
             <h3>Zusatzoptionen</h3>
-            <div v-for="addon in event.addons" :key="addon.id" style="margin-bottom: 16px; padding: 12px; background: #f8fafc; border-radius: 8px;">
+            <div v-for="addon in event.addons" :key="addon.key"
+                 style="margin-bottom: 16px; padding: 12px; background: #f8fafc; border-radius: 8px;">
                 <label style="display: flex; gap: 12px; cursor: pointer;">
-                    <input type="checkbox" v-model="selectedAddons[addon.id]" style="margin-top: 4px;" />
+                    <input type="checkbox" v-model="selectedAddons[addon.key]" style="margin-top: 4px;"/>
                     <span>
-                        <strong>{{ addon.name }}</strong>
+                        <strong>{{ addon.title }}</strong>
-                        <span style="display: block; color: #6b7280; font-size: 0.875rem;">Betrag: {{ addon.amount }}</span>
+                        <span style="display: block; color: #6b7280; font-size: 0.875rem;">
-                        <span style="display: block; color: #374151; font-size: 0.875rem; margin-top: 4px;">{{ addon.description }}</span>
+                            <template v-if="addon.free">Kostenfrei</template>
+                            <template v-else>{{ addon.priceReadable }}<template
+                                v-if="!addon.flat"> / Tag</template></template>
+                        </span>
+                        <span v-if="addon.description"
+                              style="display: block; color: #374151; font-size: 0.875rem; margin-top: 4px;">{{
+                                addon.description
+                            }}</span>
                     </span>
                 </label>
             </div>
@@ -39,7 +51,7 @@ const emit = defineEmits(['next', 'back'])
 
         <div class="btn-row">
             <button type="button" class="btn-secondary" @click="emit('back', 5)">← Zurück</button>
-            <button type="button" class="btn-primary" @click="emit('next', 7)">Weiter →</button>
+            <button type="button" class="btn-primary" @click="next">Weiter →</button>
         </div>
     </div>
 </template>

app/Domains/Event/Views/Partials/SignUpForm/steps/StepAllergies.vue

@@ -43,8 +43,8 @@ const emit = defineEmits(['next', 'back'])
             </tr>
             <tr>
                 <td colspan="2" class="btn-row">
-                    <button type="button" class="btn-secondary" @click="emit('back', 7)">← Zurück</button>
+                    <button type="button" class="btn-secondary" @click="emit('back', 8)">← Zurück</button>
-                    <button type="button" class="btn-primary" @click="emit('next', 9)">Weiter →</button>
+                    <button type="button" class="btn-primary" @click="emit('next', 10)">Weiter →</button>
                 </td>
             </tr>
         </table>

app/Domains/Event/Views/Partials/SignUpForm/steps/StepParticipationOptions.vue

@@ -0,0 +1,62 @@
+<script setup>
+import {computed} from "vue";
+import {nextVisibleFrom, prevVisibleFrom, STEP_PARTICIPATION_OPTIONS} from "../composables/stepFlow.js";
+
+const props = defineProps({formData: Object, event: Object})
+const emit = defineEmits(['next', 'back'])
+
+const questions = computed(() => props.event.participationOptions ?? [])
+
+// Pflichtfeld: "Weiter" erst möglich, wenn jede Frage beantwortet ist.
+const canProceed = computed(() =>
+    questions.value.every(q => {
+        const value = props.formData.participationOptions[q.key]
+        return value !== undefined && value !== null && String(value).trim() !== ''
+    })
+)
+
+const back = () => emit('back', prevVisibleFrom(props.event, STEP_PARTICIPATION_OPTIONS))
+const next = () => emit('next', nextVisibleFrom(props.event, STEP_PARTICIPATION_OPTIONS))
+</script>
+
+<template>
+    <div>
+        <h3>Teilnahmeoptionen</h3>
+        <p style="color: #6b7280; font-size: 0.95rem; margin-bottom: 20px;">
+            Bitte triff für jede Auswahl eine Entscheidung.
+        </p>
+
+        <table class="form-table">
+            <tr v-for="question in questions" :key="question.key">
+                <td>
+                    {{ question.title || question.label }}:
+                    <span v-if="question.title && question.label" class="option-hint">{{ question.label }}</span>
+                </td>
+                <td>
+                    <select v-model="formData.participationOptions[question.key]">
+                        <option value="">Bitte wählen</option>
+                        <option v-for="option in question.options" :key="option.value" :value="option.value">
+                            {{ option.label }}
+                        </option>
+                    </select>
+                </td>
+            </tr>
+        </table>
+
+        <div class="btn-row">
+            <button type="button" class="btn-secondary" @click="back">← Zurück</button>
+            <button type="button" class="btn-primary" :disabled="!canProceed" @click="next">Weiter →</button>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+.option-hint {
+    display: block;
+    margin-top: 2px;
+    font-size: 0.8rem;
+    font-style: italic;
+    font-weight: 400;
+    color: #6b7280;
+}
+</style>

app/Domains/Event/Views/Partials/SignUpForm/steps/StepPaymentMethod.vue

@@ -78,8 +78,8 @@ const canProceed = computed(() => {
         </div>
 
         <div class="btn-row">
-            <button type="button" class="btn-secondary" @click="emit('back', 8)">← Zurück</button>
+            <button type="button" class="btn-secondary" @click="emit('back', 9)">← Zurück</button>
-            <button type="button" class="btn-primary" :disabled="!canProceed" @click="emit('next', 10)">Weiter →
+            <button type="button" class="btn-primary" :disabled="!canProceed" @click="emit('next', 11)">Weiter →
             </button>
         </div>
     </div>

app/Domains/Event/Views/Partials/SignUpForm/steps/StepPhotoPermissions.vue

@@ -1,16 +1,15 @@
 <script setup>
+import {prevVisibleFrom, STEP_ALLERGIES, STEP_PHOTO} from "../composables/stepFlow.js";
+
 const props = defineProps({ formData: Object, event: Object })
 const emit = defineEmits(['next', 'back'])
 
 const acceptAll = () => {
     Object.keys(props.formData.foto).forEach(k => props.formData.foto[k] = true)
-    emit('next', 8)
+    emit('next', STEP_ALLERGIES)
 }
 
-const back = () => {
+const back = () => emit('back', prevVisibleFrom(props.event, STEP_PHOTO))
-    const hasAddons = (props.event.addons?.length > 0) || props.event.solidarityPayment
-    emit('back', hasAddons ? 6 : 5)
-}
 </script>
 
 <template>
@@ -27,7 +26,7 @@ const back = () => {
         <div class="btn-row">
             <button type="button" class="btn-secondary" @click="back">← Zurück</button>
             <button type="button" class="btn-primary" style="background: #059669;" @click="acceptAll">Alle akzeptieren & weiter</button>
-            <button type="button" class="btn-primary" @click="emit('next', 8)">Weiter →</button>
+            <button type="button" class="btn-primary" @click="emit('next', 9)">Weiter →</button>
         </div>
     </div>
 </template>

app/Domains/Event/Views/Partials/SignUpForm/steps/StepRegistrationMode.vue

@@ -1,5 +1,6 @@
 <script setup>
 import {watch} from "vue";
+import {nextVisibleFrom, STEP_REGISTRATION} from "../composables/stepFlow.js";
 
 const props = defineProps({ formData: Object, event: Object })
 const emit = defineEmits(['next', 'back'])
@@ -17,8 +18,7 @@ watch(
 )
 
 const nextStep = () => {
-    const hasAddons = (props.event.addons?.length ?? 0) > 0
+    emit('next', nextVisibleFrom(props.event, STEP_REGISTRATION))
-    emit('next', hasAddons ? 6 : 7)
 }
 </script>
 

app/Domains/Event/Views/Partials/SignUpForm/steps/StepSummary.vue

@@ -7,6 +7,8 @@ const PAYMENT_ACCOUNT_TRANSACTION = 'PAYMENT_ACCOUNT_TRANSACTION'
 const props = defineProps({
     formData: Object,
     event: Object,
+    summaryBaseAmount: {type: String, default: ''},
+    summaryAddonLines: {type: Array, default: () => []},
     summaryAmount: String,
     summaryAmountValue: {type: Number, default: 0},
     summaryLoading: Boolean,
@@ -32,8 +34,17 @@ const paymentConfirmationText = computed(() => {
     return template.replaceAll('{amount}', props.summaryAmount ?? '')
 })
 
-// Zurück führt zur Zahlungsart (9), sofern dieser Schritt gezeigt wurde; bei 0 € direkt zu Allergien (8).
+// Zurück führt zur Zahlungsart (10), sofern dieser Schritt gezeigt wurde; bei 0 € direkt zu Allergien (9).
-const backTarget = computed(() => props.summaryAmountValue > 0 ? 9 : 8)
+const backTarget = computed(() => props.summaryAmountValue > 0 ? 10 : 9)
+
+// Gewählte Teilnahmeoptionen für die Zusammenfassung (label statt value anzeigen).
+const selectedParticipationOptions = computed(() =>
+    (props.event.participationOptions ?? []).map(question => {
+        const value = props.formData.participationOptions[question.key]
+        const option = (question.options ?? []).find(o => o.value === value)
+        return {label: question.title || question.label, value: option?.label ?? ''}
+    }).filter(entry => entry.value !== '')
+)
 
 const canSubmit = computed(() =>
     props.formData.summary_information_correct
@@ -115,6 +126,11 @@ function eatingHabit() {
                     <td>{{ participationGroup() }}</td>
                 </tr>
 
+                <tr v-for="option in selectedParticipationOptions" :key="option.label">
+                    <td>{{ option.label }}:</td>
+                    <td>{{ option.value }}</td>
+                </tr>
+
                 <tr>
                     <td>Foto-Erlaubnis:</td>
                     <td>
@@ -149,6 +165,22 @@ function eatingHabit() {
                 <tr><td>Abreise:</td><td>{{ formatDate(formData.departure) }}</td></tr>
             </table>
 
+            <h4 style="margin: 0 0 8px 0;">Kostenübersicht</h4>
+            <table class="form-table cost-table" style="margin-bottom: 20px;">
+                <tr>
+                    <td>Teilnahmebeitrag:</td>
+                    <td>{{ summaryBaseAmount }}</td>
+                </tr>
+                <tr v-for="addon in summaryAddonLines" :key="addon.key">
+                    <td>{{ addon.title }}:</td>
+                    <td>{{ addon.free ? 'Kostenfrei' : addon.amount }}</td>
+                </tr>
+                <tr class="cost-total">
+                    <td><strong>Gesamtbetrag:</strong></td>
+                    <td><strong>{{ summaryAmount }}</strong></td>
+                </tr>
+            </table>
+
             <div style="display: flex; flex-direction: column; gap: 10px; margin-bottom: 20px;">
                 <label style="display: flex; gap: 10px; cursor: pointer;">
                     <input type="checkbox" v-model="formData.summary_information_correct" />
@@ -182,3 +214,10 @@ function eatingHabit() {
         </div>
     </div>
 </template>
+
+<style scoped>
+.cost-table .cost-total td {
+    border-top: 1px solid #d1d5db;
+    padding-top: 8px;
+}
+</style>

app/Domains/Invoice/Views/Partials/newInvoice/direct-payment.vue

@@ -1,6 +1,6 @@
 <script setup>
 
-import { ref, onMounted, reactive } from 'vue'
+import { ref, computed, onMounted, reactive } from 'vue'
 import {checkFilesize} from "../../../../../../resources/js/components/InvoiceUploadChecks.js";
 import RefundData from "./refund-data.vue";
 import AmountInput from "../../../../../Views/Components/AmountInput.vue";
@@ -38,6 +38,20 @@ onMounted(async () => {
     Object.assign(invoiceTypeCollection, data);
 });
 
+/**
+ * Das Beispiel im Feld "Was wurde eingekauft" kommt aus `invoice_types.purchase_example` und ist damit
+ * ohne Deployment pflegbar. Ein allgemeines "z. B. Material" hilft beim Ausfüllen nicht weiter, und von
+ * genau diesem Text lebt später die Zweck-Spalte der EüR-Belegliste.
+ *
+ * Ist am Typ nichts gepflegt, greift der allgemeine Text -- ein Feld ohne jede Hilfestellung wäre
+ * schlechter als ein unscharfes Beispiel.
+ */
+const purchasePlaceholder = computed(() => {
+    const selected = Object.values(invoiceTypeCollection.invoiceTypes)
+        .find((type) => type.slug === invoiceType.value)
+
+    return selected?.purchaseExample || 'z. B. Material für die Veranstaltung'
+})
 
 function handleFileChange(event) {
     if (checkFilesize('receipt')) {
@@ -66,28 +80,36 @@ function handleFileChange(event) {
             <InfoIcon :text="'INFO_INVOICE_TYPE_' + availableInvoiceType.slug" /><br />
         </p>
 
+    </fieldset><br /><br />
 
-        <label for="invoice_type_other">
+    <!--
+        Pflichtangabe zu jeder Rechnung, nicht nur zu "Sonstige Kosten": Erst dieser Text sagt, wofür das
+        Geld ausgegeben wurde, und füllt damit die Zweck-Spalte der EüR-Belegliste.
+
+        Die Schritte bauen aufeinander auf -- ohne Ausgabenart gäbe es kein passendes Beispiel für den
+        Einkauf, und ein Betrag ohne Zweck ließe sich später nicht mehr zuordnen.
+    -->
+    <template v-if="invoiceType !== null">
+        <fieldset>
+            <legend><span style="font-weight: bolder;">Was wurde eingekauft</span></legend>
             <input
                 type="text"
                 class="width-full"
-                name="kostengruppe_sonstiges"
+                id="purchase_description"
-                placeholder="Sonstige"
+                name="purchase_description"
-                for="invoice_type_other"
+                :placeholder="purchasePlaceholder"
                 v-model="otherText"
-                @focus="invoiceType = 'other'"
             />
-        </label>
-
         </fieldset><br /><br />
+    </template>
 
-    <fieldset>
+    <fieldset v-if="invoiceType !== null && otherText.trim() !== ''">
         <legend><span style="font-weight: bolder;">Wie hoch ist der Betrag</span></legend>
         <AmountInput v-model="amount" class="width-small" id="amount" name="amount"  /> Euro
         <info-icon></info-icon><br /><br />
 
         <input
-            v-if="amount != '' && invoiceType !== null"
+            v-if="amount != ''"
             class="mareike-button"
             onclick="document.getElementById('receipt').click();"
             type="button"

app/Domains/Invoice/Views/Partials/newInvoice/expense-accounting.vue

@@ -1,6 +1,6 @@
 <script setup>
 
-import { ref, onMounted, reactive } from 'vue'
+import { ref, computed, onMounted, reactive } from 'vue'
 import {checkFilesize} from "../../../../../../resources/js/components/InvoiceUploadChecks.js";
 import RefundData from "./refund-data.vue";
 import AmountInput from "../../../../../Views/Components/AmountInput.vue";
@@ -37,6 +37,20 @@ onMounted(async () => {
     Object.assign(invoiceTypeCollection, data);
 });
 
+/**
+ * Das Beispiel im Feld "Was wurde eingekauft" kommt aus `invoice_types.purchase_example` und ist damit
+ * ohne Deployment pflegbar. Ein allgemeines "z. B. Material" hilft beim Ausfüllen nicht weiter, und von
+ * genau diesem Text lebt später die Zweck-Spalte der EüR-Belegliste.
+ *
+ * Ist am Typ nichts gepflegt, greift der allgemeine Text -- ein Feld ohne jede Hilfestellung wäre
+ * schlechter als ein unscharfes Beispiel.
+ */
+const purchasePlaceholder = computed(() => {
+    const selected = Object.values(invoiceTypeCollection.invoiceTypes)
+        .find((type) => type.slug === invoiceType.value)
+
+    return selected?.purchaseExample || 'z. B. Material für die Veranstaltung'
+})
 
 function handleFileChange(event) {
     if (checkFilesize('receipt')) {
@@ -65,28 +79,36 @@ function handleFileChange(event) {
             <InfoIcon :text="'INFO_INVOICE_TYPE_' + availableInvoiceType.slug" /><br />
         </p>
 
+    </fieldset><br /><br />
 
-        <label for="invoice_type_other">
+    <!--
+        Pflichtangabe zu jeder Abrechnung, nicht nur zu "Sonstige Kosten": Erst dieser Text sagt, wofür
+        das Geld ausgegeben wurde, und füllt damit die Zweck-Spalte der EüR-Belegliste.
+
+        Die Schritte bauen aufeinander auf -- ohne Ausgabenart gäbe es kein passendes Beispiel für den
+        Einkauf, und ein Betrag ohne Zweck ließe sich später nicht mehr zuordnen.
+    -->
+    <template v-if="invoiceType !== null">
+        <fieldset>
+            <legend><span style="font-weight: bolder;">Was wurde eingekauft</span></legend>
             <input
                 type="text"
                 class="width-full"
-                name="kostengruppe_sonstiges"
+                id="purchase_description"
-                placeholder="Sonstige"
+                name="purchase_description"
-                for="invoice_type_other"
+                :placeholder="purchasePlaceholder"
                 v-model="otherText"
-                @focus="invoiceType = 'other'"
             />
-        </label>
-
         </fieldset><br /><br />
+    </template>
 
-    <fieldset>
+    <fieldset v-if="invoiceType !== null && otherText.trim() !== ''">
         <legend><span style="font-weight: bolder;">Wie hoch ist der Betrag</span></legend>
         <AmountInput v-model="amount" class="width-small" id="amount" name="amount"  /> Euro
         <info-icon></info-icon><br /><br />
 
         <input
-            v-if="amount != '' && invoiceType !== null"
+            v-if="amount != ''"
             class="mareike-button"
             onclick="document.getElementById('receipt').click();"
             type="button"

app/Domains/ParticipantInvoice/Actions/CreateParticipantInvoice/CreateParticipantInvoiceCommand.php

@@ -0,0 +1,418 @@
+<?php
+
+namespace App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice;
+
+use App\Enumerations\TaxExemptionReason;
+use App\EventPaymentModules\DTO\CreateInvoiceRequest;
+use App\Models\DocumentTemplate;
+use App\Models\Event;
+use App\Models\EventParticipant;
+use App\Models\Tenant;
+use App\Providers\DocumentTemplateRenderProvider;
+use App\Providers\PdfGenerateAndDownloadProvider;
+use App\RelationModels\EventParticipationFee;
+use App\Support\DateRange;
+use App\ValueObjects\Amount;
+
+/**
+ * Erzeugt die Rechnung über den Teilnahmebeitrag als PDF.
+ *
+ * Es wird nichts gespeichert: die Rechnungsnummer ergibt sich deterministisch aus Veranstaltung und
+ * Position des Teilis, der Inhalt aus dessen aktuellem Stand. Ein erneuter Abruf liefert unter derselben
+ * Nummer den dann gültigen Stand.
+ */
+class CreateParticipantInvoiceCommand
+{
+    private EventParticipant $participant;
+
+    private Event $event;
+
+    /** Der Rechnungssteller. Gehört zum Mandanten, nicht zur Veranstaltung -- siehe buildTokens(). */
+    private ?Tenant $sender;
+
+    public function __construct(private readonly CreateParticipantInvoiceRequest $request)
+    {
+        $this->participant = $request->participant;
+        $this->event = $request->participant->event;
+
+        // Über die Relation und nicht über app('tenant'): die Rechnung hängt an der Veranstaltung,
+        // nicht am gerade aktiven Mandanten. `$event->tenant` liefert das Slug-Attribut, nicht die
+        // Relation -- deshalb der ausdrückliche Aufruf.
+        $this->sender = $this->event->tenant()->first();
+    }
+
+    public function execute(): CreateParticipantInvoiceResponse
+    {
+        $response = new CreateParticipantInvoiceResponse();
+
+        if ($this->event->invoice_key === null || $this->participant->invoice_sequence === null) {
+            $response->message = 'Für diese Anmeldung lässt sich keine Rechnungsnummer bilden.';
+
+            return $response;
+        }
+
+        $invoiceNumber = sprintf(
+            '%s-%s',
+            $this->event->invoice_key,
+            str_pad((string) $this->participant->invoice_sequence, 4, '0', STR_PAD_LEFT)
+        );
+
+        $lines = $this->buildLines();
+        $gross = round($this->participant->amount?->getAmount() ?? 0.0, 2);
+
+        $html = new DocumentTemplateRenderProvider(DocumentTemplate::TYPE_PARTICIPANT_INVOICE)
+            ->render($this->buildTokens($invoiceNumber, $lines, $gross));
+
+        $response->success = true;
+        $response->invoiceNumber = $invoiceNumber;
+        $response->filename = 'Rechnung-' . $invoiceNumber . '.pdf';
+        $response->pdfContent = PdfGenerateAndDownloadProvider::fromHtml($html, 'portrait');
+
+        return $response;
+    }
+
+    /**
+     * Die Rechnungspositionen.
+     *
+     * Der Beitragsanteil wird nicht neu berechnet, sondern aus dem gespeicherten Gesamtbetrag abgeleitet:
+     * `amount` ist Beitrag + Zusätze (siehe SignupController), die Zusätze liegen als Snapshot-Zeilen vor.
+     * Damit stimmt die Rechnung immer mit dem überein, was der Teili tatsächlich zahlen soll -- unabhängig
+     * davon, ob die Beiträge der Veranstaltung inzwischen geändert wurden oder der Early-Bird-Stichtag
+     * verstrichen ist.
+     *
+     * @return array<int, array{description: string, quantity: ?float, unit: string, unitPrice: ?float, amount: float}>
+     */
+    private function buildLines(): array
+    {
+        $addons = $this->participant->selectedAddons;
+
+        $addonTotal = 0.0;
+        foreach ($addons as $addon) {
+            $addonTotal += $addon->amount?->getAmount() ?? 0.0;
+        }
+
+        $fee = round(($this->participant->amount?->getAmount() ?? 0.0) - $addonTotal, 2);
+        $days = $this->attendanceDays();
+
+        // Die Preiskette in EventResource::calculateAmount() besteht nur aus Multiplikationen; der Faktor
+        // 0,5 der Geschwisterermäßigung wirkt damit auf den gesamten Endbetrag. Der Listenpreis ist also
+        // exakt das Doppelte des gespeicherten Beitragsanteils, der Rabatt genau dieser Anteil.
+        $listed = $this->participant->sibling_reduction ? round($fee * 2, 2) : $fee;
+
+        $lines = [$this->line(
+            $this->feeDescription(),
+            $listed,
+            $this->event->pay_per_day ? $days : 1
+        )];
+
+        if ($this->participant->sibling_reduction) {
+            $lines[] = [
+                'description' => 'Geschwisterermäßigung 50 %',
+                'quantity' => null,
+                'unit' => '',
+                'unitPrice' => null,
+                'amount' => -$fee,
+            ];
+        }
+
+        foreach ($addons as $addon) {
+            $lines[] = $this->line(
+                (string) $addon->title,
+                $addon->amount?->getAmount() ?? 0.0,
+                $addon->flat ? 1 : (int) $addon->days
+            );
+        }
+
+        return $lines;
+    }
+
+    /**
+     * Eine Position mit Mengenaufteilung -- aber nur, wenn sie aufgeht.
+     *
+     * Der Endbetrag ist gerundet gespeichert; bei krummen Tagessätzen (etwa nach einem
+     * Early-Bird-Aufschlag) ergäbe Menge × gerundeter Einzelpreis einen anderen Wert als der Betrag der
+     * Zeile. Eine Rechnung, deren Positionen sich nicht nachrechnen lassen, ist unbrauchbar -- in dem
+     * Fall entfällt die Aufteilung und die Position steht als Gesamtbetrag da.
+     *
+     * @return array{description: string, quantity: ?float, unit: string, unitPrice: ?float, amount: float}
+     */
+    private function line(string $description, float $amount, int $quantity): array
+    {
+        $amount = round($amount, 2);
+
+        if ($quantity > 1) {
+            $unitPrice = round($amount / $quantity, 2);
+
+            if (abs($unitPrice * $quantity - $amount) < 0.005) {
+                return [
+                    'description' => $description,
+                    'quantity' => (float) $quantity,
+                    'unit' => 'Tage',
+                    'unitPrice' => $unitPrice,
+                    'amount' => $amount,
+                ];
+            }
+        }
+
+        return [
+            'description' => $description,
+            'quantity' => 1.0,
+            'unit' => '',
+            'unitPrice' => $amount,
+            'amount' => $amount,
+        ];
+    }
+
+    /**
+     * Bezeichnung der Beitragsposition. Der Gruppenname stammt aus dem am Event hinterlegten Beitrag,
+     * dessen `type` der Teilnahmeart entspricht -- dieselbe Auflösung wie in EventResource.
+     */
+    private function feeDescription(): string
+    {
+        $group = $this->participationFee()?->name;
+
+        $description = $group !== null && trim($group) !== ''
+            ? sprintf('Teilnahme %s in Gruppe %s', $this->event->name, $group)
+            : sprintf('Teilnahme %s', $this->event->name);
+
+        $feeTypeLabel = match ($this->participant->fee_type) {
+            'standard' => 'Standardbeitrag',
+            'reduced' => 'Reduzierter Beitrag',
+            'solidarity' => 'Solidaritätsbeitrag',
+            // Altanmeldungen vor Einführung von `fee_type` -- dann bleibt der Zusatz weg.
+            default => null,
+        };
+
+        return $feeTypeLabel === null
+            ? $description
+            : sprintf('%s (%s)', $description, $feeTypeLabel);
+    }
+
+    private function participationFee(): ?EventParticipationFee
+    {
+        return collect([
+            $this->event->participationFee1,
+            $this->event->participationFee2,
+            $this->event->participationFee3,
+            $this->event->participationFee4,
+        ])
+            ->filter(fn(?EventParticipationFee $fee) => $fee !== null)
+            ->first(fn(EventParticipationFee $fee) => $fee->type === $this->participant->participation_type);
+    }
+
+    private function attendanceDays(): int
+    {
+        $arrival = $this->participant->arrival_date;
+        $departure = $this->participant->departure_date;
+
+        if ($arrival === null || $departure === null) {
+            return 1;
+        }
+
+        return DateRange::inclusiveDays($arrival, $departure);
+    }
+
+    /**
+     * Umsatzsteuer aus dem Brutto herausrechnen. Gespeichert ist immer der finale Brutto-Betrag -- beim
+     * Preismodus `add_on` wurde die USt bereits bei der Anmeldung aufgeschlagen, bei `inclusive` war sie
+     * von Anfang an enthalten. Für die Rechnung ist die Rechnung deshalb in beiden Fällen dieselbe, der
+     * Preismodus spielt hier keine Rolle mehr.
+     *
+     * @return array{net: float, vat: float}
+     */
+    private function splitVat(float $gross): array
+    {
+        if (!$this->event->tax_liable || $this->event->vat_rate <= 0) {
+            return ['net' => $gross, 'vat' => 0.0];
+        }
+
+        $vat = round($gross * $this->event->vat_rate / (100 + $this->event->vat_rate), 2);
+
+        return ['net' => round($gross - $vat, 2), 'vat' => $vat];
+    }
+
+    /**
+     * Der je Zahlungsart variierende Schlusssatz, bezogen auf den noch offenen Betrag.
+     */
+    private function closingStatement(): string
+    {
+        $module = $this->participant->paymentModule();
+        if ($module === null) {
+            return '';
+        }
+
+        $open = new Amount($this->participant->amount?->getAmount() ?? 0.0, 'Euro');
+        if ($this->participant->amount_paid !== null) {
+            $open->subtractAmount($this->participant->amount_paid);
+        }
+
+        $result = $module->createInvoice(new CreateInvoiceRequest(
+            $this->event,
+            $this->participant,
+            $open,
+            $this->participant->paymentConfiguration(),
+        ));
+
+        return (string) ($result->closingStatement ?? '');
+    }
+
+    /**
+     * Leistungszeitraum: bei eintägigen Veranstaltungen nur ein Datum, sonst der Zeitraum.
+     */
+    private function servicePeriod(): string
+    {
+        $start = $this->event->start_date;
+        $end = $this->event->end_date;
+
+        if ($start === null) {
+            return '';
+        }
+
+        if ($end === null || $start->isSameDay($end)) {
+            return $start->format('d.m.Y');
+        }
+
+        return sprintf('%s – %s', $start->format('d.m.Y'), $end->format('d.m.Y'));
+    }
+
+    /**
+     * @param array<int, array<string, mixed>> $lines
+     * @return array<string, string>
+     */
+    private function buildTokens(string $invoiceNumber, array $lines, float $gross): array
+    {
+        $participant = $this->participant;
+        $sender = $this->sender;
+
+        return [
+            'document_title' => 'Rechnung ' . $invoiceNumber,
+
+            'invoice_number' => $invoiceNumber,
+            // Rechnungsdatum ist das Anmeldedatum, Leistungsdatum der Veranstaltungszeitraum.
+            'invoice_date' => $participant->created_at?->format('d.m.Y') ?? '',
+            'service_period' => $this->servicePeriod(),
+
+            // Der Rechnungssteller wird live vom Mandanten gelesen, nicht auf der Veranstaltung
+            // eingefroren: eine Korrektur an Name oder Anschrift soll auch auf bestehende
+            // Veranstaltungen wirken. Eingefroren bleibt nur, was den Preis erklärt (Steuergrundlage)
+            // und die Nummer (invoice_key).
+            'sender_name' => $sender?->invoiceSenderName() ?? '',
+            'sender_address_1' => (string) $sender?->address_1,
+            'sender_address_2' => (string) $sender?->address_2,
+            'sender_address_3' => (string) $sender?->address_3,
+            'sender_postcode' => (string) $sender?->postcode,
+            'sender_city' => (string) $sender?->city,
+            'sender_email' => (string) $sender?->email,
+            'sender_phone' => (string) $sender?->phone,
+            'sender_tax_number' => (string) $sender?->tax_number,
+            'sender_vat_id' => (string) $sender?->vat_id,
+
+            'recipient_name' => $participant->getOfficialName(),
+            'recipient_address_1' => (string) $participant->address_1,
+            'recipient_address_2' => (string) $participant->address_2,
+            'recipient_postcode' => (string) $participant->postcode,
+            'recipient_city' => (string) $participant->city,
+
+            'positions_table' => $this->renderPositions($lines),
+            'summary_table' => $this->renderSummary($gross),
+            'closing_statement' => $this->closingStatement(),
+        ];
+    }
+
+    /** @param array<int, array<string, mixed>> $lines */
+    private function renderPositions(array $lines): string
+    {
+        $rows = '';
+        foreach ($lines as $index => $line) {
+            $quantity = $line['quantity'] === null
+                ? ''
+                : trim($this->quantity((float) $line['quantity']) . ' ' . $line['unit']);
+
+            $rows .= sprintf(
+                '<tr><td>%d</td><td>%s</td><td class="r">%s</td><td class="r">%s</td><td class="r">%s</td></tr>',
+                $index + 1,
+                e((string) $line['description']),
+                e($quantity),
+                $line['unitPrice'] === null ? '' : $this->money((float) $line['unitPrice']),
+                $this->money((float) $line['amount']),
+            );
+        }
+
+        return '<table class="pos-table">'
+            . '<thead><tr>'
+            . '<th style="width:8%;">Nr.</th>'
+            . '<th style="width:44%;">Bezeichnung</th>'
+            . '<th style="width:12%;" class="r">Menge</th>'
+            . '<th style="width:18%;" class="r">Einzelpreis</th>'
+            . '<th style="width:18%;" class="r">Gesamt</th>'
+            . '</tr></thead>'
+            . '<tbody>' . $rows . '</tbody>'
+            . '</table>';
+    }
+
+    /**
+     * Summenblock. Bei Steuerpflicht wird die USt aus dem Brutto ausgewiesen, sonst steht statt der
+     * USt-Zeile der Pflichthinweis nach § 14 Abs. 4 Nr. 8 UStG.
+     */
+    private function renderSummary(float $gross): string
+    {
+        $rows = '';
+
+        if ($this->event->tax_liable && $this->event->vat_rate > 0) {
+            $split = $this->splitVat($gross);
+
+            $rows .= sprintf(
+                '<tr><td class="sum-key">Nettobetrag</td><td class="sum-val">%s</td></tr>',
+                $this->money($split['net'])
+            );
+            $rows .= sprintf(
+                '<tr class="sum-line"><td class="sum-key">enthaltene USt. %d&nbsp;%%</td><td class="sum-val">%s</td></tr>',
+                $this->event->vat_rate,
+                $this->money($split['vat'])
+            );
+        }
+
+        $rows .= sprintf(
+            '<tr class="sum-total"><td class="sum-key">Gesamtbetrag</td><td class="sum-val">%s</td></tr>',
+            $this->money($gross)
+        );
+
+        $table = '<table class="sum-outer"><tr><td class="sum-spacer"></td><td>'
+            . '<table class="sum-inner">' . $rows . '</table>'
+            . '</td></tr></table>';
+
+        return $table . $this->taxExemptionNote();
+    }
+
+    /** Pflichthinweis auf den Grund der Steuerbefreiung, aus dem Event-Snapshot. */
+    private function taxExemptionNote(): string
+    {
+        if ($this->event->tax_liable) {
+            return '';
+        }
+
+        $reason = $this->event->tax_exemption_reason !== null
+            ? TaxExemptionReason::find($this->event->tax_exemption_reason)
+            : null;
+
+        $text = $reason?->invoiceText($this->event->tax_exemption_note);
+        if ($text === null || trim($text) === '') {
+            return '';
+        }
+
+        return '<div class="tax-note">' . e($text) . '</div>';
+    }
+
+    private function money(float $value): string
+    {
+        return new Amount($value, 'Euro')->getFormattedAmount() . '&nbsp;&euro;';
+    }
+
+    /** Mengen ohne Nachkommastellen, solange sie ganzzahlig sind ("3 Tage", nicht "3,00 Tage"). */
+    private function quantity(float $value): string
+    {
+        return abs($value - round($value)) < 0.005
+            ? (string) (int) round($value)
+            : number_format($value, 2, ',', '.');
+    }
+}

app/Domains/ParticipantInvoice/Actions/CreateParticipantInvoice/CreateParticipantInvoiceRequest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice;
+
+use App\Models\EventParticipant;
+
+class CreateParticipantInvoiceRequest
+{
+    public function __construct(
+        public readonly EventParticipant $participant,
+    ) {
+    }
+}

app/Domains/ParticipantInvoice/Actions/CreateParticipantInvoice/CreateParticipantInvoiceResponse.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice;
+
+class CreateParticipantInvoiceResponse
+{
+    public bool $success = false;
+
+    public string $invoiceNumber = '';
+
+    public string $filename = '';
+
+    public string $pdfContent = '';
+
+    public ?string $message = null;
+}

app/Domains/ParticipantInvoice/Controllers/CreateParticipantInvoiceController.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Domains\ParticipantInvoice\Controllers;
+
+use App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice\CreateParticipantInvoiceCommand;
+use App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice\CreateParticipantInvoiceRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\Response;
+
+class CreateParticipantInvoiceController extends CommonController
+{
+    public function __invoke(string $participantIdentifier): Response
+    {
+        $participant = $this->eventParticipants->getByIdentifier($participantIdentifier, $this->events);
+
+        if ($participant === null) {
+            abort(403, 'Zugriff verweigert.');
+        }
+
+        $invoiceRequest = new CreateParticipantInvoiceRequest($participant);
+        $invoiceCommand = new CreateParticipantInvoiceCommand($invoiceRequest);
+        $invoiceResponse = $invoiceCommand->execute();
+
+        if (!$invoiceResponse->success) {
+            abort(422, $invoiceResponse->message ?? 'Die Rechnung konnte nicht erstellt werden.');
+        }
+
+        return response($invoiceResponse->pdfContent, 200, [
+            'Content-Type' => 'application/pdf',
+            'Content-Disposition' => 'attachment; filename="' . $invoiceResponse->filename . '"',
+        ]);
+    }
+}

app/Domains/ParticipantInvoice/ParticipantInvoiceTokens.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Domains\ParticipantInvoice;
+
+/**
+ * Katalog der Platzhalter, die in der Rechnungsvorlage zur Verfügung stehen.
+ *
+ * Dient zwei Zwecken: der Platzhalter-Liste in der Vorlagen-Verwaltung und den Beispieldaten für die
+ * Vorschau. Die echten Werte setzt
+ * {@see \App\Domains\ParticipantInvoice\Actions\CreateParticipantInvoice\CreateParticipantInvoiceCommand}
+ * zusammen -- dass beide Seiten dieselben Namen kennen, sichert ein Test ab.
+ */
+final class ParticipantInvoiceTokens
+{
+    /**
+     * Platzhalter nach Gruppen, je Eintrag Name, Beschreibung und Beispielwert.
+     *
+     * @return array<string, array{label: string, tokens: array<string, array{description: string, sample: string}>}>
+     */
+    public static function groups(): array
+    {
+        return [
+            'document' => [
+                'label' => 'Dokument',
+                'tokens' => [
+                    'document_title' => ['description' => 'Titel des PDF-Dokuments', 'sample' => 'Rechnung WM-V-20260701-0005'],
+                    'invoice_number' => ['description' => 'Rechnungsnummer', 'sample' => 'WM-V-20260701-0005'],
+                    'invoice_date' => ['description' => 'Rechnungsdatum (= Anmeldedatum)', 'sample' => '03.02.2026'],
+                    'service_period' => ['description' => 'Leistungszeitraum der Veranstaltung', 'sample' => '16.07.2026 – 20.07.2026'],
+                ],
+            ],
+            'sender' => [
+                'label' => 'Absender',
+                'tokens' => [
+                    'sender_name' => ['description' => 'Rechnungs-Absender (Standard: Name des Mandanten)', 'sample' => 'BdP Landesverband Sachsen e.V.'],
+                    'sender_address_1' => ['description' => 'Straße und Hausnummer', 'sample' => 'Musterweg 1'],
+                    'sender_address_2' => ['description' => 'Adresszusatz, z. B. „c/o …"', 'sample' => 'c/o Mustermensch'],
+                    'sender_address_3' => ['description' => 'Weiterer Adresszusatz', 'sample' => ''],
+                    'sender_postcode' => ['description' => 'Postleitzahl', 'sample' => '01623'],
+                    'sender_city' => ['description' => 'Ort', 'sample' => 'Lommatzsch'],
+                    'sender_email' => ['description' => 'E-Mail-Adresse', 'sample' => 'kontakt@example.com'],
+                    'sender_phone' => ['description' => 'Telefonnummer', 'sample' => '0351 1234567'],
+                    'sender_tax_number' => ['description' => 'Steuernummer', 'sample' => '201/123/45678'],
+                    'sender_vat_id' => ['description' => 'USt-IdNr.', 'sample' => ''],
+                ],
+            ],
+            'recipient' => [
+                'label' => 'Empfänger',
+                'tokens' => [
+                    'recipient_name' => ['description' => 'Name der teilnehmenden Person', 'sample' => 'Mika Muster'],
+                    'recipient_address_1' => ['description' => 'Straße und Hausnummer', 'sample' => 'Beispielstraße 3'],
+                    'recipient_address_2' => ['description' => 'Adresszusatz', 'sample' => ''],
+                    'recipient_postcode' => ['description' => 'Postleitzahl', 'sample' => '11111'],
+                    'recipient_city' => ['description' => 'Ort', 'sample' => 'Beispielstadt'],
+                ],
+            ],
+            'body' => [
+                'label' => 'Rechnungsinhalt (generiert)',
+                'tokens' => [
+                    'positions_table' => ['description' => 'Positionstabelle', 'sample' => self::samplePositions()],
+                    'summary_table' => ['description' => 'Summenblock inkl. USt bzw. Befreiungshinweis', 'sample' => self::sampleSummary()],
+                    'closing_statement' => ['description' => 'Zahlungshinweis der gewählten Zahlungsart', 'sample' => 'Bitte überweise 300,00 Euro bis zum 01.07.2026 auf folgendes Konto:<br />IBAN: DE00 0000 0000 0000 0000 00'],
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * Beispielwerte für die Vorschau.
+     *
+     * @return array<string, string>
+     */
+    public static function sample(): array
+    {
+        $sample = [];
+
+        foreach (self::groups() as $group) {
+            foreach ($group['tokens'] as $name => $token) {
+                $sample[$name] = $token['sample'];
+            }
+        }
+
+        return $sample;
+    }
+
+    /** @return array<int, string> */
+    public static function names(): array
+    {
+        return array_keys(self::sample());
+    }
+
+    private static function samplePositions(): string
+    {
+        return '<table class="pos-table">'
+            . '<thead><tr>'
+            . '<th style="width:8%;">Nr.</th><th style="width:44%;">Bezeichnung</th>'
+            . '<th style="width:12%;" class="r">Menge</th><th style="width:18%;" class="r">Einzelpreis</th>'
+            . '<th style="width:18%;" class="r">Gesamt</th>'
+            . '</tr></thead><tbody>'
+            . '<tr><td>1</td><td>Teilnahme Sommerlager in Gruppe Sippe (Standardbeitrag)</td>'
+            . '<td class="r">5 Tage</td><td class="r">60,00&nbsp;&euro;</td><td class="r">300,00&nbsp;&euro;</td></tr>'
+            . '</tbody></table>';
+    }
+
+    private static function sampleSummary(): string
+    {
+        return '<table class="sum-outer"><tr><td class="sum-spacer"></td><td>'
+            . '<table class="sum-inner">'
+            . '<tr class="sum-total"><td class="sum-key">Gesamtbetrag</td><td class="sum-val">300,00&nbsp;&euro;</td></tr>'
+            . '</table></td></tr></table>';
+    }
+}

app/Domains/ParticipantInvoice/Routes/api.php

@@ -0,0 +1,14 @@
+<?php
+
+use App\Domains\ParticipantInvoice\Controllers\CreateParticipantInvoiceController;
+use App\Middleware\IdentifyTenant;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('api/v1')
+    ->group(function () {
+        Route::middleware(IdentifyTenant::class)->group(function () {
+            Route::middleware(['auth'])->group(function () {
+                Route::get('participant-invoice/{participantIdentifier}', CreateParticipantInvoiceController::class);
+            });
+        });
+    });

app/Domains/ParticipantRefund/Actions/AcceptRefund/AcceptRefundCommand.php

@@ -0,0 +1,311 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\AcceptRefund;
+
+use App\Domains\Invoice\Actions\CreateInvoice\CreateInvoiceCommand;
+use App\Domains\Invoice\Actions\CreateInvoice\CreateInvoiceRequest;
+use App\Domains\ParticipantRefund\Actions\CreateRefundDocument\CreateRefundDocumentCommand;
+use App\Domains\ParticipantRefund\Actions\CreateRefundDocument\CreateRefundDocumentRequest;
+use App\Domains\ParticipantRefund\Actions\CreateRefundDocument\CreateRefundDocumentResponse;
+use App\Enumerations\InvoiceType;
+use App\Mail\ParticipantRefundMails\RefundAcceptedMail;
+use App\Models\CostUnit;
+use App\Models\Invoice;
+use App\Models\ParticipantRefund;
+use App\Providers\FileWriteProvider;
+use App\Providers\UploadFileProvider;
+use App\Repositories\CostUnitRepository;
+use App\Support\Iban;
+use App\ValueObjects\Amount;
+use App\ValueObjects\InvoiceFile;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+/**
+ * Der Teili bestätigt die Erstattung und hinterlegt seine Bankverbindung.
+ *
+ * Läuft ohne Login -- der Token aus der Mail ist die Autorisierung, dasselbe Modell wie bei
+ * /print-girocode/{identifier}. Betrag und Grund stehen fest und werden hier nicht angefasst: sie kommen
+ * aus der Freigabe der Aktionsleitung.
+ *
+ * Danach ist der Vorgang festgeschrieben; der Beleg geht mit der Bestätigungsmail raus.
+ */
+class AcceptRefundCommand
+{
+    /**
+     * Wortlaut für jeden Fall, in dem der Link nicht (mehr) zu einem offenen Vorgang führt.
+     *
+     * Bewusst ein und derselbe Text für „Token unbekannt" und „abgebrochen": eine abgebrochene Freigabe
+     * soll sich verhalten, als hätte es sie nie gegeben.
+     */
+    public const string NO_OPEN_REFUND = 'Zu deiner Anmeldung liegt keine freigegebene Rückerstattung vor. '
+        . 'Bitte wende dich an die Aktionsleitung.';
+
+    public function __construct(private readonly AcceptRefundRequest $request)
+    {
+    }
+
+    public function execute(): AcceptRefundResponse
+    {
+        $response = new AcceptRefundResponse();
+        $refund = $this->request->refund;
+
+        if ($refund === null || !$refund->isPending()) {
+            $response->message = $refund?->isAccepted() === true
+                ? 'Deine Angaben liegen uns bereits vor.'
+                : self::NO_OPEN_REFUND;
+
+            return $response;
+        }
+
+        $owner = trim($this->request->accountOwner);
+        $iban = Iban::normalize($this->request->accountIban);
+
+        // Serverseitig und nicht nur im Formular: die Erklärung ist der einzige Grund, warum der Beleg
+        // als Eigenbeleg etwas wert ist. Ließe sie sich mit einem direkten Aufruf übergehen, stünde auf
+        // dem PDF eine Zusicherung, die niemand abgegeben hat.
+        //
+        // Nimmt die Aktionsleitung die Angaben auf, kreuzt naturgemäß niemand etwas an. Nachvollziehbar
+        // bleibt es trotzdem: `captured_by` hält fest, wer sie aufgenommen hat, und der Beleg weist es aus.
+        if (!$this->request->declarationAccepted && $this->request->capturedBy === null) {
+            $response->errorTypes['declaration'] = 'Bitte bestätige die Erklärung, damit wir erstatten können.';
+        }
+
+        if ($owner === '') {
+            $response->errorTypes['accountOwner'] = 'Bitte gib an, wem das Konto gehört.';
+        }
+
+        if ($iban === '') {
+            $response->errorTypes['accountIban'] = 'Bitte gib die IBAN des Kontos ein.';
+        } elseif (!Iban::isValid($iban)) {
+            $response->errorTypes['accountIban'] = 'Diese IBAN stimmt nicht. Bitte prüfe deine Eingabe.';
+        }
+
+        if ($response->errorTypes !== []) {
+            $response->message = 'Bitte prüfe deine Angaben.';
+
+            return $response;
+        }
+
+        // Ohne Kostenstelle gibt es nichts, worauf gebucht werden könnte. Lieber hier abbrechen, als den
+        // Vorgang zu bestätigen und die Auszahlung stillschweigend nirgends einzureichen.
+        $costUnit = $this->costUnit($refund);
+        if ($costUnit === null) {
+            $response->message = 'Die Erstattung kann gerade nicht bearbeitet werden. '
+                . 'Bitte wende dich an die Aktionsleitung.';
+
+            Log::error('Beitragserstattung: Veranstaltung ohne Kostenstelle, Abrechnung nicht möglich.', [
+                'refund_id' => $refund->id,
+                'event_id' => $refund->event_id,
+            ]);
+
+            return $response;
+        }
+
+        // Der Beleg entsteht in der Transaktion, weil er den bestätigten Stand abbildet; scheitert das
+        // Einreichen, soll auch kein Beleg gelten.
+        $document = DB::transaction(function () use ($refund, $owner, $iban, $costUnit) {
+            $refund->account_owner = $owner;
+            $refund->account_iban = $iban;
+            $refund->captured_by = $this->request->capturedBy;
+            $refund->status = ParticipantRefund::STATUS_ACCEPTED;
+            $refund->accepted_at = now();
+            $refund->save();
+
+            $document = new CreateRefundDocumentCommand(new CreateRefundDocumentRequest($refund))->execute();
+
+            $invoice = $this->createInvoice($refund, $costUnit, $document);
+
+            // Erst jetzt, nicht früher: Beleg und Anmerkung der Abrechnung weisen den gezahlten Beitrag
+            // aus und läsen sonst bereits den verrechneten Stand.
+            $this->settleAmountPaid($refund);
+
+            $refund->invoice_id = $invoice->id;
+            $refund->save();
+
+            return $document;
+        });
+
+        $this->notify($refund, $document);
+
+        $response->success = true;
+        $response->message = 'Vielen Dank. Deine Angaben liegen uns vor.';
+
+        return $response;
+    }
+
+    /**
+     * Die Kostenstelle der Veranstaltung.
+     *
+     * Ohne Zugriffsprüfung, weil hier niemand angemeldet ist -- der Teili bestätigt über seinen Token.
+     * Der Repository-Check greift sonst auf `auth()->user()->id` zu und liefe in einen Fehler.
+     *
+     * Bewusst ohne Prüfung auf `allow_new`/`archived`: Eine Erstattung fällt oft erst nach dem Ende der
+     * Veranstaltung an, wenn die Kostenstelle längst geschlossen ist. Sie gehört trotzdem dorthin -- und
+     * der reguläre Weg über SaveInvoiceController prüft das ebenso wenig.
+     */
+    private function costUnit(ParticipantRefund $refund): ?CostUnit
+    {
+        if ($refund->event->cost_unit_id === null) {
+            return null;
+        }
+
+        return new CostUnitRepository()->getById($refund->event->cost_unit_id, true);
+    }
+
+    /**
+     * Reicht die Erstattung als gewöhnliche Auslagenabrechnung ein.
+     *
+     * Über denselben Command wie jede von Hand erfasste Abrechnung: damit stimmen Nummernkreis, Status
+     * `new`, die Bestätigungsmail an den Teili und die Benachrichtigung der Kassenwart*innen mit dem
+     * überein, was die Buchhaltung kennt.
+     */
+    private function createInvoice(
+        ParticipantRefund $refund,
+        CostUnit $costUnit,
+        CreateRefundDocumentResponse $document,
+    ): Invoice {
+        $participant = $refund->participant;
+
+        $invoiceRequest = new CreateInvoiceRequest(
+            costUnit: $costUnit,
+            // getOfficialName() und nicht getFullName(): letzteres enthält HTML für die Oberfläche.
+            contactName: $participant->getOfficialName(),
+            invoiceType: InvoiceType::INVOICE_TYPE_PARTICIPATION_REFUND,
+            totalAmount: $refund->amount?->getAmount() ?? 0.0,
+            receiptFile: $this->storeReceipt($costUnit, $document),
+            isDonation: false,
+            userId: $participant->user_id,
+            contactEmail: $participant->email_1,
+            contactPhone: $participant->phone_1,
+            // Die Bankverbindung stammt aus dem Vorgang, nicht vom Teilnehmer: das Konto kann einem
+            // Elternteil gehören.
+            accountOwner: $refund->account_owner,
+            accountIban: $refund->account_iban,
+
+            // Die folgenden vier gehören zu Reisekosten und Freitext-Typen und sind hier leer. Sie
+            // müssen trotzdem stehen: `transportations` hat als einziger Parameter keinen Vorgabewert,
+            // und PHP macht damit auch alle optionalen Parameter davor zu Pflichtangaben.
+            invoiceTypeExtended: null,
+            travelRoute: null,
+            distance: null,
+            passengers: null,
+            transportations: null,
+
+            // MUSS null bleiben (nicht ''): CreateInvoiceCommand verwirft die user_id, sobald hier etwas
+            // steht -- der Teili fände seine Abrechnung dann nicht unter "Meine Abrechnungen".
+            paymentPurpose: null,
+            notices: $this->notice($refund),
+        );
+
+        $invoiceResponse = new CreateInvoiceCommand($invoiceRequest)->execute();
+
+        if (!$invoiceResponse->success || $invoiceResponse->invoice === null) {
+            // Rollt die Transaktion zurück -- der Vorgang bleibt offen, der Teili kann es erneut versuchen.
+            throw new RuntimeException('Die Abrechnung zur Beitragserstattung konnte nicht angelegt werden.');
+        }
+
+        return $invoiceResponse->invoice;
+    }
+
+    /**
+     * Legt den Eigenbeleg dort ab, wo auch hochgeladene Belege liegen, und verpackt ihn für die
+     * Abrechnung. `CreateInvoiceCommand` speichert nur den Pfad und schreibt selbst keine Dateien.
+     */
+    private function storeReceipt(CostUnit $costUnit, CreateRefundDocumentResponse $document): ?InvoiceFile
+    {
+        if (!$document->success) {
+            return null;
+        }
+
+        $path = UploadFileProvider::directoryFor($costUnit) . '/' . $document->filename;
+
+        new FileWriteProvider($path, $document->pdfContent)->writeToFile();
+
+        $receipt = new InvoiceFile();
+        // Beide Eigenschaften sind typisiert und ohne Vorbelegung; gespeichert wird nur `fullPath`.
+        $receipt->filename = $document->filename;
+        $receipt->fullPath = $path;
+
+        return $receipt;
+    }
+
+    /**
+     * Die Anmerkung auf der Abrechnung.
+     *
+     * Sie nennt den gezahlten Beitrag, weil er am Teilnehmer gleich auf 0 gesetzt wird
+     * ({@see self::clearAmountPaid()}) -- die Schatzmeisterei kann den Vorgang so nachvollziehen, ohne
+     * den vorherigen Stand irgendwo suchen zu müssen.
+     *
+     * Gekürzt wird nur der vordere, freie Teil: Veranstaltungsname und Grund sind beliebig lang, der
+     * Betrag darf nie abgeschnitten werden.
+     */
+    private function notice(ParticipantRefund $refund): string
+    {
+        $paid = $refund->participant->amount_paid?->toString() ?? '0,00 Euro';
+
+        return Str::limit(sprintf(
+            'Rückerstattung Teilnahmebeitrag %s – %s',
+            $refund->event->name,
+            $refund->reasonLabel()
+        ), 180) . sprintf(' | Gezahlter Beitrag vor Erstattung: %s', $paid);
+    }
+
+    /**
+     * Zieht den erstatteten Betrag vom gezahlten Beitrag ab.
+     *
+     * Danach führt `amount_paid` genau das, was beim Verband geblieben ist -- bei voller Erstattung also
+     * 0, bei einer Teilerstattung den einbehaltenen Rest. Auf diesem Feld baut die Einnahmenrechnung der
+     * Veranstaltung auf; es muss deshalb den tatsächlichen Bestand abbilden und nicht die Zahlung von
+     * einst. Der ursprüngliche Betrag steht zur Kontrolle in der Anmerkung der Abrechnung und auf dem
+     * Beleg.
+     */
+    private function settleAmountPaid(ParticipantRefund $refund): void
+    {
+        $participant = $refund->participant;
+
+        $paid = $participant->amount_paid?->getAmount() ?? 0.0;
+        $refunded = $refund->amount?->getAmount() ?? 0.0;
+
+        // `max` gegen Rundungsreste: Ein negativer gezahlter Betrag wäre in jeder Auswertung Unsinn.
+        $participant->amount_paid = new Amount(max(0.0, round($paid - $refunded, 2)), 'Euro');
+        $participant->save();
+    }
+
+    /**
+     * Die eigene Bestätigung mit dem Beleg im Anhang, an Teili und Kontaktperson.
+     *
+     * Sie kommt zusätzlich zu der, die CreateInvoiceCommand verschickt: diese trägt den Beleg, jene ist
+     * die Quittung des Abrechnungssystems. Erst nach der Transaktion, damit nichts verschickt wird, was
+     * anschließend zurückgerollt würde.
+     *
+     * Scheitert die Belegerzeugung, geht die Mail ohne Anhang raus statt gar nicht.
+     */
+    private function notify(ParticipantRefund $refund, CreateRefundDocumentResponse $document): void
+    {
+        $pdf = $document->success ? $document->pdfContent : null;
+        $filename = $document->success ? $document->filename : null;
+
+        $participant = $refund->participant;
+
+        $recipients = [$participant->email_1];
+
+        // `filled()` und nicht `!== null`: Der Anmeldewizard überspringt den Schritt "Kontaktperson" bei
+        // Volljährigen und legt das Feld als Leerstring an -- `Mail::to('')` liefe ins Leere.
+        if (filled($participant->email_2)) {
+            $recipients[] = $participant->email_2;
+        }
+
+        foreach ($recipients as $recipient) {
+            Mail::to($recipient)->send(new RefundAcceptedMail(
+                participant: $participant,
+                refund: $refund,
+                pdfContent: $pdf,
+                pdfFilename: $filename,
+            ));
+        }
+    }
+}

app/Domains/ParticipantRefund/Actions/AcceptRefund/AcceptRefundRequest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\AcceptRefund;
+
+use App\Models\ParticipantRefund;
+
+class AcceptRefundRequest
+{
+    public function __construct(
+        public readonly ?ParticipantRefund $refund,
+        public readonly string $accountOwner,
+        public readonly string $accountIban,
+        /** Ob der Teili die Erklärung auf der Seite angekreuzt hat. Ohne sie taugt der Beleg nichts. */
+        public readonly bool $declarationAccepted = false,
+        /**
+         * Die Aktionsleitung, wenn sie die Bankverbindung aufgenommen hat, weil sie ihr vorlag.
+         *
+         * Dann kreuzt niemand die Erklärung an -- sie wird stellvertretend aufgenommen, und der Beleg
+         * weist genau das aus.
+         */
+        public readonly ?int $capturedBy = null,
+    ) {
+    }
+}

app/Domains/ParticipantRefund/Actions/AcceptRefund/AcceptRefundResponse.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\AcceptRefund;
+
+class AcceptRefundResponse
+{
+    public bool $success = false;
+
+    public ?string $message = null;
+
+    /**
+     * Feldbezogene Fehler für das Formular. Schlüssel sind die Feldnamen des Frontends.
+     *
+     * @var array<string, string>
+     */
+    public array $errorTypes = [];
+}

app/Domains/ParticipantRefund/Actions/CancelRefund/CancelRefundCommand.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CancelRefund;
+
+use App\Models\ParticipantRefund;
+
+/**
+ * Bricht eine freigegebene, aber noch nicht bestätigte Erstattung ab.
+ *
+ * Danach läuft der Link des Teilis ins Leere und die Anmeldung sieht aus wie vor der Freigabe. Bewusst
+ * ohne Mail: der Teili soll nicht über etwas informiert werden, das für ihn nie stattgefunden hat --
+ * die Aktionsleitung klärt das im Zweifel direkt.
+ *
+ * Ein bereits bestätigter Vorgang ist unantastbar: dazu gibt es einen Beleg, und der Teili hat seine
+ * Bankverbindung im Vertrauen darauf herausgegeben.
+ */
+class CancelRefundCommand
+{
+    public function __construct(private readonly CancelRefundRequest $request)
+    {
+    }
+
+    public function execute(): CancelRefundResponse
+    {
+        $response = new CancelRefundResponse();
+        $refund = $this->request->refund;
+
+        if (!$refund->isPending()) {
+            $response->message = $refund->isAccepted()
+                ? 'Diese Erstattung wurde bereits bestätigt und kann nicht mehr abgebrochen werden.'
+                : 'Diese Erstattung wurde bereits abgebrochen.';
+
+            return $response;
+        }
+
+        $refund->status = ParticipantRefund::STATUS_CANCELLED;
+        $refund->cancelled_at = now();
+        $refund->save();
+
+        $response->success = true;
+        $response->message = 'Die Erstattung wurde abgebrochen.';
+
+        return $response;
+    }
+}

app/Domains/ParticipantRefund/Actions/CancelRefund/CancelRefundRequest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CancelRefund;
+
+use App\Models\ParticipantRefund;
+
+class CancelRefundRequest
+{
+    public function __construct(
+        public readonly ParticipantRefund $refund,
+    ) {
+    }
+}

app/Domains/ParticipantRefund/Actions/CancelRefund/CancelRefundResponse.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CancelRefund;
+
+class CancelRefundResponse
+{
+    public bool $success = false;
+
+    public ?string $message = null;
+}

app/Domains/ParticipantRefund/Actions/CreateRefundDocument/CreateRefundDocumentCommand.php

@@ -0,0 +1,300 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CreateRefundDocument;
+
+use App\Models\DocumentTemplate;
+use App\Models\Event;
+use App\Models\EventParticipant;
+use App\Models\PageText;
+use App\Models\ParticipantRefund;
+use App\Models\Tenant;
+use App\Providers\DocumentTemplateRenderProvider;
+use App\Providers\PdfGenerateAndDownloadProvider;
+use App\ValueObjects\Amount;
+
+/**
+ * Erzeugt den Beleg über die erstattete Teilnahmegebühr als PDF.
+ *
+ * Wie bei der Teilnahmerechnung wird nichts gespeichert: die Belegnummer leitet sich aus Veranstaltung
+ * und Position des Teilis ab, der Inhalt aus dem Erstattungsvorgang. Da ein bestätigter Vorgang nicht
+ * mehr verändert wird, liefert ein erneuter Abruf denselben Beleg.
+ *
+ * Keine Umsatzsteuer: eine Erstattung ist keine Rechnung. Ausgewiesen wird der Betrag, den der Teili
+ * zurückbekommt. Eine Stornorechnung mit USt-Ausweis wäre eine eigene Dokumentart.
+ */
+class CreateRefundDocumentCommand
+{
+    /** Name des `page_texts`-Eintrags mit der Erklärung -- dieselbe Quelle wie die Bestätigungsseite. */
+    public const string DECLARATION_TEXT = 'CONFIRMATION_PARTICIPANT_REFUND';
+
+    private ParticipantRefund $refund;
+
+    private EventParticipant $participant;
+
+    private Event $event;
+
+    /** Der Aussteller. Gehört zum Mandanten der Veranstaltung, nicht zum gerade aktiven. */
+    private ?Tenant $sender;
+
+    public function __construct(private readonly CreateRefundDocumentRequest $request)
+    {
+        $this->refund = $request->refund;
+        $this->participant = $request->refund->participant;
+        $this->event = $request->refund->event;
+
+        // Wie in CreateParticipantInvoiceCommand: `$event->tenant` liefert das Slug-Attribut, nicht die
+        // Relation. Der Aussteller wird live gelesen, damit eine Korrektur an Name oder Anschrift auch
+        // auf bestehende Veranstaltungen wirkt.
+        $this->sender = $this->event->tenant()->first();
+    }
+
+    public function execute(): CreateRefundDocumentResponse
+    {
+        $response = new CreateRefundDocumentResponse();
+
+        if ($this->event->invoice_key === null || $this->participant->invoice_sequence === null) {
+            $response->message = 'Für diese Anmeldung lässt sich keine Belegnummer bilden.';
+
+            return $response;
+        }
+
+        if (!$this->refund->isAccepted()) {
+            $response->message = 'Der Beleg entsteht erst, wenn die Erstattung bestätigt wurde.';
+
+            return $response;
+        }
+
+        $documentNumber = $this->documentNumber();
+
+        $html = new DocumentTemplateRenderProvider(DocumentTemplate::TYPE_PARTICIPANT_REFUND)
+            ->render($this->buildTokens($documentNumber));
+
+        $response->success = true;
+        $response->documentNumber = $documentNumber;
+        $response->filename = 'Rueckerstattung-' . $documentNumber . '.pdf';
+        $response->pdfContent = PdfGenerateAndDownloadProvider::fromHtml($html, 'portrait');
+
+        return $response;
+    }
+
+    /**
+     * Dieselbe Nummer wie die Rechnung, mit angehängtem `-R`. Kein zweiter Nummernkreis: der Beleg
+     * gehört zu genau einer Anmeldung, und so ist auf einen Blick erkennbar, zu welcher Rechnung.
+     */
+    private function documentNumber(): string
+    {
+        return $this->invoiceNumber() . '-R';
+    }
+
+    /** Die Nummer der Teilnahmerechnung -- der Beleg weist sie aus, damit die Zahlung auffindbar ist. */
+    private function invoiceNumber(): string
+    {
+        return sprintf(
+            '%s-%s',
+            $this->event->invoice_key,
+            str_pad((string) $this->participant->invoice_sequence, 4, '0', STR_PAD_LEFT)
+        );
+    }
+
+    /**
+     * Der Erklärungssatz aus `page_texts` -- derselbe, den der Teili auf der Bestätigungsseite gelesen
+     * und angekreuzt hat.
+     *
+     * Mit Rückfallwert: fehlt die Zeile in der Datenbank, soll der Beleg trotzdem entstehen. Ohne den
+     * Fallback stünde hier ein Fatal Error auf `null` -- so steht es heute im Deckblatt-Code der
+     * Auslagenerstattung, und daran soll sich der Beleg kein Beispiel nehmen.
+     */
+    /**
+     * Der Hinweis, warum ein Teil des Beitrags beim Verband bleibt -- leer bei voller Erstattung.
+     *
+     * Der Beleg wandert in die Buchhaltung und ins Archiv; dort muss die Differenz zwischen gezahltem
+     * und erstattetem Betrag ohne Rückfrage erklärt sein.
+     */
+    private function retentionNote(): string
+    {
+        if (!$this->refund->hasRetention()) {
+            return '';
+        }
+
+        $text = trim($this->refund->retentionReasonText());
+        $label = $this->refund->retentionReasonLabel();
+
+        return $text !== '' && $text !== $label
+            ? sprintf('%s (%s)', $label, $text)
+            : $label;
+    }
+
+    /**
+     * Der Vermerk, wenn die Aktionsleitung die Angaben aufgenommen hat.
+     *
+     * Er nennt Name und Datum, weil in diesem Fall niemand die Erklärung darüber angekreuzt hat: Wer den
+     * Beleg prüft, soll erkennen, dass dort eine aufgenommene Angabe steht und keine Bestätigung des
+     * Teilis selbst. Beim gewöhnlichen Weg bleibt der Platzhalter leer und der Block fällt weg.
+     */
+    private function captureNote(): string
+    {
+        if (!$this->refund->wasCapturedByManagement()) {
+            return '';
+        }
+
+        $name = $this->refund->capturedBy()->first()?->getOfficialName();
+
+        return sprintf(
+            'Angaben aufgenommen durch %s am %s.',
+            trim((string) $name) !== '' ? $name : 'die Aktionsleitung',
+            $this->refund->accepted_at?->format('d.m.Y') ?? ''
+        );
+    }
+
+    private function declarationText(): string
+    {
+        $text = PageText::where('name', self::DECLARATION_TEXT)->first()?->content;
+
+        return trim((string) $text) !== ''
+            ? (string) $text
+            : 'Ich versichere, dass ich den genannten Betrag beglichen habe und nicht anderweitig '
+                . 'zurückerstattet bekomme.';
+    }
+
+    /**
+     * Leistungszeitraum: bei eintägigen Veranstaltungen nur ein Datum, sonst der Zeitraum.
+     */
+    private function servicePeriod(): string
+    {
+        $start = $this->event->start_date;
+        $end = $this->event->end_date;
+
+        if ($start === null) {
+            return '';
+        }
+
+        if ($end === null || $start->isSameDay($end)) {
+            return $start->format('d.m.Y');
+        }
+
+        return sprintf('%s – %s', $start->format('d.m.Y'), $end->format('d.m.Y'));
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function buildTokens(string $documentNumber): array
+    {
+        $participant = $this->participant;
+        $sender = $this->sender;
+        $refund = $this->refund;
+
+        return [
+            'document_title' => 'Rückerstattung ' . $documentNumber,
+
+            'document_number' => $documentNumber,
+            // Belegdatum ist der Tag, an dem der Teili bestätigt hat -- da stand der Vorgang fest.
+            'document_date' => $refund->accepted_at?->format('d.m.Y') ?? '',
+            'event_name' => (string) $this->event->name,
+            'service_period' => $this->servicePeriod(),
+            'unregistered_at' => $participant->unregistered_at?->format('d.m.Y') ?? '',
+
+            'sender_name' => $sender?->invoiceSenderName() ?? '',
+            'sender_address_1' => (string) $sender?->address_1,
+            'sender_address_2' => (string) $sender?->address_2,
+            'sender_address_3' => (string) $sender?->address_3,
+            'sender_postcode' => (string) $sender?->postcode,
+            'sender_city' => (string) $sender?->city,
+            'sender_email' => (string) $sender?->email,
+            'sender_phone' => (string) $sender?->phone,
+            'sender_tax_number' => (string) $sender?->tax_number,
+            'sender_vat_id' => (string) $sender?->vat_id,
+
+            'recipient_name' => $participant->getOfficialName(),
+            'recipient_address_1' => (string) $participant->address_1,
+            'recipient_address_2' => (string) $participant->address_2,
+            'recipient_postcode' => (string) $participant->postcode,
+            'recipient_city' => (string) $participant->city,
+
+            'paid_amount' => $this->money($participant->amount_paid?->getAmount() ?? 0.0),
+            'invoice_number' => $this->invoiceNumber(),
+            'refund_amount' => $this->money($refund->amount?->getAmount() ?? 0.0),
+            'refund_reason' => $refund->reasonLabel(),
+            'refund_reason_text' => $refund->reasonText(),
+            'account_owner' => (string) $refund->account_owner,
+            'account_iban' => $this->formatIban((string) $refund->account_iban),
+
+            'retained_amount' => $this->money($refund->retained_amount?->getAmount() ?? 0.0),
+            'retention_note' => $this->retentionNote(),
+
+            'declaration_text' => $this->declarationText(),
+            'capture_note' => $this->captureNote(),
+
+            'details_table' => $this->renderDetails(),
+        ];
+    }
+
+    /**
+     * Der generierte Block: wer erklärt, worauf sich die Erstattung bezieht, warum, und auf welches
+     * Konto sie geht.
+     *
+     * Alles, was die Person erklärt, steht in dieser einen Tabelle -- auch die Begründung, die früher als
+     * Fließtext darunter hing. Was daneben steht (Anschrift im Briefkopf, Veranstaltung im Betreff),
+     * beschreibt den Vorgang, gehört aber nicht zur Erklärung selbst.
+     */
+    private function renderDetails(): string
+    {
+        $refund = $this->refund;
+        $participant = $this->participant;
+
+        $rows = [
+            // Der Name steht voran: die Tabelle trägt alles, was die Person erklärt, und die Anschrift
+            // allein im Briefkopf würde den Bezug lösen, sobald der Beleg als Anlage hinter einem
+            // Deckblatt liegt. Kontoinhaber*in weiter unten kann eine andere Person sein -- etwa ein
+            // Elternteil.
+            ['Name', e($participant->getOfficialName())],
+
+            // Der gezahlte Beitrag ist die Bezugsgröße. Ohne ihn lässt sich bei einer Teilerstattung
+            // nicht erkennen, warum nur ein Teil zurückgeht -- und die Zusicherung „ich habe den Betrag
+            // beglichen" bliebe unbelegt, obwohl mareike ihn kennt.
+            ['Gezahlter Teilnahmebeitrag', $this->money($participant->amount_paid?->getAmount() ?? 0.0)],
+            ['Rechnung', e($this->invoiceNumber())],
+            ['Erstattungsbetrag', $this->money($refund->amount?->getAmount() ?? 0.0)],
+            ['Grund', e($refund->reasonLabel())],
+        ];
+
+        // Bei einem Freitext-Grund ist die Begründung der Text der Aktionsleitung, sonst der des
+        // Katalogs. Fehlt beides, entfällt die Zeile -- eine Beschriftung ohne Wert sieht nach Fehler aus.
+        $reasonText = trim($refund->reasonText());
+        if ($reasonText !== '') {
+            $rows[] = ['Begründung', e($reasonText)];
+        }
+
+        // Nur bei einer Teilerstattung: Ohne diese Zeile bliebe die Differenz zwischen gezahltem und
+        // erstattetem Betrag im Beleg unerklärt.
+        if ($refund->hasRetention()) {
+            $rows[] = ['Einbehalten', $this->money($refund->retained_amount?->getAmount() ?? 0.0)];
+            $rows[] = ['Grund der Einbehaltung', e($this->retentionNote())];
+        }
+
+        $rows[] = ['Kontoinhaber*in', e((string) $refund->account_owner)];
+        $rows[] = ['IBAN', e($this->formatIban((string) $refund->account_iban))];
+
+        $html = '';
+        foreach ($rows as [$key, $value]) {
+            $html .= sprintf(
+                '<tr><td class="detail-key">%s</td><td class="detail-val">%s</td></tr>',
+                e($key),
+                $value
+            );
+        }
+
+        return '<table class="detail-table">' . $html . '</table>';
+    }
+
+    /** IBAN in Vierergruppen -- so steht sie auf jedem Beleg und lässt sich abtippen. */
+    private function formatIban(string $iban): string
+    {
+        return trim(chunk_split($iban, 4, ' '));
+    }
+
+    private function money(float $value): string
+    {
+        return new Amount($value, 'Euro')->getFormattedAmount() . '&nbsp;&euro;';
+    }
+}

app/Domains/ParticipantRefund/Actions/CreateRefundDocument/CreateRefundDocumentRequest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CreateRefundDocument;
+
+use App\Models\ParticipantRefund;
+
+class CreateRefundDocumentRequest
+{
+    public function __construct(
+        public readonly ParticipantRefund $refund,
+    ) {
+    }
+}

app/Domains/ParticipantRefund/Actions/CreateRefundDocument/CreateRefundDocumentResponse.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\CreateRefundDocument;
+
+class CreateRefundDocumentResponse
+{
+    public bool $success = false;
+
+    public string $documentNumber = '';
+
+    public string $filename = '';
+
+    public string $pdfContent = '';
+
+    public ?string $message = null;
+}

app/Domains/ParticipantRefund/Actions/ReleaseRefund/ReleaseRefundCommand.php

@@ -0,0 +1,266 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\ReleaseRefund;
+
+use App\Domains\ParticipantRefund\Actions\AcceptRefund\AcceptRefundCommand;
+use App\Domains\ParticipantRefund\Actions\AcceptRefund\AcceptRefundRequest;
+use App\Enumerations\RefundReason;
+use App\Enumerations\RetentionReason;
+use App\Mail\ParticipantRefundMails\RefundReleasedMail;
+use App\Models\EventParticipant;
+use App\Models\ParticipantRefund;
+use App\Repositories\ParticipantRefundRepository;
+use App\Support\Iban;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+/**
+ * Gibt die Erstattung eines Teilnahmebeitrags frei.
+ *
+ * Der Vorgang entsteht hier nur als Absichtserklärung: Betrag und Grund stehen fest, die Bankverbindung
+ * fehlt noch. Der Teili ergänzt sie über den Link in der Mail. `amount_paid` bleibt unangetastet --
+ * gezahlt hat er bis zur Auszahlung weiterhin, was er gezahlt hat.
+ */
+class ReleaseRefundCommand
+{
+    private EventParticipant $participant;
+
+    private ParticipantRefundRepository $refunds;
+
+    public function __construct(private readonly ReleaseRefundRequest $request)
+    {
+        $this->participant = $request->participant;
+        $this->refunds = new ParticipantRefundRepository();
+    }
+
+    public function execute(): ReleaseRefundResponse
+    {
+        $response = new ReleaseRefundResponse();
+
+        $rejection = $this->reject();
+        if ($rejection !== null) {
+            $response->message = $rejection;
+
+            return $response;
+        }
+
+        // Liegt die Bankverbindung schon vor, entsteht in einem Zug auch die Abrechnung. Scheitert die,
+        // soll keine halbe Freigabe zurückbleiben -- deshalb beides in einer Transaktion.
+        $refund = DB::transaction(function (): ParticipantRefund {
+            $refund = ParticipantRefund::create([
+                'tenant' => $this->participant->tenant,
+                'event_id' => $this->participant->event_id,
+                'event_participant_id' => $this->participant->id,
+                'token' => Str::random(32),
+                'status' => ParticipantRefund::STATUS_PENDING,
+                'amount' => $this->request->amount,
+                'reason' => $this->request->reason,
+                'reason_note' => $this->reasonNote(),
+                // Was beim Verband bleibt, wird hier festgeschrieben: Nach dem Einreichen führt
+                // `amount_paid` bereits diesen Rest, eine spätere Differenz wäre falsch.
+                'retained_amount' => $this->request->retainedAmount(),
+                'retention_reason' => $this->retentionReason(),
+                'retention_reason_note' => $this->retentionReasonNote(),
+                'released_by' => auth()->id(),
+                'released_at' => now(),
+            ]);
+
+            if ($this->request->hasBankDetails()) {
+                $this->submitDirectly($refund);
+            }
+
+            return $refund;
+        });
+
+        if (!$this->request->hasBankDetails()) {
+            $this->notify($refund);
+        }
+
+        $response->success = true;
+        $response->refund = $refund->fresh();
+        $response->message = $this->request->hasBankDetails()
+            ? 'Die Erstattung wurde eingereicht. Der Teili hat den Beleg per E-Mail erhalten.'
+            : 'Die Erstattung wurde freigegeben. Der Teili wurde per E-Mail informiert.';
+
+        return $response;
+    }
+
+    /**
+     * Reicht die Erstattung sofort ein, ohne den Umweg über den Teili.
+     *
+     * Über denselben Command, den sonst der Bestätigungslink auslöst: Beleg, Abrechnung, das Nullstellen
+     * des gezahlten Beitrags und die Mail mit dem Beleg laufen dadurch in beiden Wegen identisch ab.
+     */
+    private function submitDirectly(ParticipantRefund $refund): void
+    {
+        $acceptResponse = new AcceptRefundCommand(new AcceptRefundRequest(
+            refund: $refund,
+            accountOwner: (string) $this->request->accountOwner,
+            accountIban: (string) $this->request->accountIban,
+            // Niemand kreuzt hier eine Erklärung an; wer die Angaben aufgenommen hat, hält `captured_by`
+            // fest, und der Beleg weist es aus.
+            capturedBy: auth()->id(),
+        ))->execute();
+
+        if (!$acceptResponse->success) {
+            // Rollt die Freigabe zurück -- die Aktionsleitung soll den Fehler sehen und nicht einen
+            // Vorgang vorfinden, der nirgends eingereicht ist.
+            throw new RuntimeException($acceptResponse->message ?? 'Die Erstattung konnte nicht eingereicht werden.');
+        }
+    }
+
+    /**
+     * Alle Gründe, aus denen eine Freigabe nicht zulässig ist.
+     *
+     * @return string|null Meldung, oder null wenn nichts dagegen spricht.
+     */
+    private function reject(): ?string
+    {
+        if ($this->participant->unregistered_at === null) {
+            return 'Eine Erstattung ist nur für abgemeldete Teilis möglich.';
+        }
+
+        if ($this->refunds->openFor($this->participant) !== null) {
+            return 'Für diese Anmeldung läuft bereits eine Erstattung.';
+        }
+
+        $amount = $this->request->amount->getAmount();
+        if ($amount <= 0) {
+            return 'Der Erstattungsbetrag muss größer als 0 sein.';
+        }
+
+        // Mehr zurückgeben als eingegangen ist wäre keine Erstattung mehr. Die halbe Cent-Toleranz
+        // fängt die Rundung des gespeicherten Floats ab.
+        $paid = $this->participant->amount_paid?->getAmount() ?? 0.0;
+        if ($amount > $paid + 0.005) {
+            return 'Der Erstattungsbetrag darf den gezahlten Beitrag nicht übersteigen.';
+        }
+
+        $reason = RefundReason::find($this->request->reason);
+        if ($reason === null) {
+            return 'Bitte wähle einen Erstattungsgrund aus.';
+        }
+
+        if ($reason->requires_note && trim((string) $this->request->reasonNote) === '') {
+            return 'Für diesen Grund ist eine Erläuterung erforderlich.';
+        }
+
+        return $this->rejectRetention() ?? $this->rejectBankDetails();
+    }
+
+    /**
+     * Prüfungen zum einbehaltenen Teil.
+     *
+     * Sicherheitsnetz hinter der Oberfläche: Dort erscheint der Absende-Knopf erst, wenn ein Grund
+     * gewählt ist. Über einen direkten Aufruf ginge das sonst vorbei, und ein einbehaltener Betrag ohne
+     * Begründung ist in der Buchhaltung nicht haltbar.
+     */
+    private function rejectRetention(): ?string
+    {
+        if (!$this->request->hasRetention()) {
+            return null;
+        }
+
+        $reason = RetentionReason::find($this->request->retentionReason);
+        if ($reason === null) {
+            return 'Bitte gib an, warum ein Teil des Beitrags einbehalten wird.';
+        }
+
+        if ($reason->requires_note && trim((string) $this->request->retentionReasonNote) === '') {
+            return 'Für diesen Einbehaltungsgrund ist eine Erläuterung erforderlich.';
+        }
+
+        return null;
+    }
+
+    /**
+     * Prüfungen, die nur den Direktweg betreffen -- die Erstattung wird dabei sofort eingereicht, es gibt
+     * also keine zweite Gelegenheit, Angaben zu berichtigen.
+     */
+    private function rejectBankDetails(): ?string
+    {
+        // Halb ausgefüllt ist keine Absicht: entweder beides oder der Weg über den Teili.
+        if (filled($this->request->accountOwner) !== filled($this->request->accountIban)) {
+            return 'Für die sofortige Erstattung werden Kontoinhaber*in und IBAN benötigt.';
+        }
+
+        if (!$this->request->hasBankDetails()) {
+            return null;
+        }
+
+        if (!Iban::isValid((string) $this->request->accountIban)) {
+            return 'Diese IBAN stimmt nicht. Bitte prüfe die Eingabe.';
+        }
+
+        // Ohne Kostenstelle ließe sich die Abrechnung nicht anlegen. Hier abfangen und nicht erst in der
+        // Transaktion, damit die Aktionsleitung eine verständliche Meldung sieht.
+        if ($this->participant->event->cost_unit_id === null) {
+            return 'Die Veranstaltung hat keine Kostenstelle -- die Erstattung kann nicht eingereicht werden.';
+        }
+
+        return null;
+    }
+
+    /** Der Freitext gehört nur zu Gründen, die ihn verlangen -- sonst stünde er ungenutzt in der DB. */
+    private function reasonNote(): ?string
+    {
+        $reason = RefundReason::find($this->request->reason);
+
+        if ($reason === null || !$reason->requires_note) {
+            return null;
+        }
+
+        return trim((string) $this->request->reasonNote);
+    }
+
+    /**
+     * Der Einbehaltungsgrund -- nur, wenn tatsächlich etwas beim Verband bleibt.
+     *
+     * Bei voller Erstattung wird ein mitgeschickter Grund verworfen: In der Oberfläche ist das Feld dann
+     * gar nicht sichtbar, und ein Wert ohne Bezug hätte in der Datenbank nichts zu suchen.
+     */
+    private function retentionReason(): ?string
+    {
+        return $this->request->hasRetention() ? $this->request->retentionReason : null;
+    }
+
+    /** Der Freitext dazu -- wie beim Erstattungsgrund nur bei Gründen, die ihn verlangen. */
+    private function retentionReasonNote(): ?string
+    {
+        if (!$this->request->hasRetention()) {
+            return null;
+        }
+
+        $reason = RetentionReason::find($this->request->retentionReason);
+
+        if ($reason === null || !$reason->requires_note) {
+            return null;
+        }
+
+        return trim((string) $this->request->retentionReasonNote);
+    }
+
+    /**
+     * Teili und Kontaktperson bekommen je eine eigene Mail -- dasselbe Muster wie bei der Abmeldung
+     * (siehe SetParticipationStateCommand).
+     */
+    private function notify(ParticipantRefund $refund): void
+    {
+        $recipients = [$this->participant->email_1];
+
+        // `filled()` und nicht `!== null`: Der Anmeldewizard überspringt den Schritt "Kontaktperson" bei
+        // Volljährigen und legt das Feld als Leerstring an -- `Mail::to('')` liefe ins Leere.
+        if (filled($this->participant->email_2)) {
+            $recipients[] = $this->participant->email_2;
+        }
+
+        foreach ($recipients as $recipient) {
+            Mail::to($recipient)->send(new RefundReleasedMail(
+                participant: $this->participant,
+                refund: $refund,
+            ));
+        }
+    }
+}

app/Domains/ParticipantRefund/Actions/ReleaseRefund/ReleaseRefundRequest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\ReleaseRefund;
+
+use App\Models\EventParticipant;
+use App\ValueObjects\Amount;
+
+class ReleaseRefundRequest
+{
+    public function __construct(
+        public readonly EventParticipant $participant,
+        public readonly Amount $amount,
+        public readonly string $reason,
+        public readonly ?string $reasonNote = null,
+        /**
+         * Die Bankverbindung, wenn sie der Aktionsleitung bereits vorliegt.
+         *
+         * Sind beide gesetzt, entfällt der Umweg über den Teili: die Erstattung wird sofort eingereicht.
+         * Bleiben sie leer, läuft der übliche Weg über den Bestätigungslink.
+         */
+        public readonly ?string $accountOwner = null,
+        public readonly ?string $accountIban = null,
+        /**
+         * Warum ein Teil des Beitrags beim Verband bleibt.
+         *
+         * Pflicht, sobald weniger erstattet wird als gezahlt wurde: Ein einbehaltener Betrag ohne Grund
+         * ist in der Buchhaltung nicht haltbar.
+         */
+        public readonly ?string $retentionReason = null,
+        public readonly ?string $retentionReasonNote = null,
+    ) {
+    }
+
+    /** Ob die Erstattung ohne Zutun des Teilis eingereicht werden kann. */
+    public function hasBankDetails(): bool
+    {
+        return filled($this->accountOwner) && filled($this->accountIban);
+    }
+
+    /**
+     * Der Betrag, der beim Verband bleibt.
+     *
+     * Die halbe Cent-Toleranz fängt die Rundung des gespeicherten Floats ab -- ohne sie entstünden
+     * Restbeträge von Bruchteilen eines Cents, die eine Begründung verlangen würden.
+     */
+    public function retainedAmount(): float
+    {
+        $paid = $this->participant->amount_paid?->getAmount() ?? 0.0;
+        $remaining = round($paid - $this->amount->getAmount(), 2);
+
+        return $remaining > 0.005 ? $remaining : 0.0;
+    }
+
+    public function hasRetention(): bool
+    {
+        return $this->retainedAmount() > 0.0;
+    }
+}

app/Domains/ParticipantRefund/Actions/ReleaseRefund/ReleaseRefundResponse.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Actions\ReleaseRefund;
+
+use App\Models\ParticipantRefund;
+
+class ReleaseRefundResponse
+{
+    public bool $success = false;
+
+    public ?ParticipantRefund $refund = null;
+
+    public ?string $message = null;
+}

app/Domains/ParticipantRefund/Controllers/AcceptRefundController.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Controllers;
+
+use App\Domains\ParticipantRefund\Actions\AcceptRefund\AcceptRefundCommand;
+use App\Domains\ParticipantRefund\Actions\AcceptRefund\AcceptRefundRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+/**
+ * Öffentlich erreichbar -- der Token aus der Mail ist die Autorisierung.
+ */
+class AcceptRefundController extends CommonController
+{
+    public function __invoke(string $refundToken, Request $request): JsonResponse
+    {
+        $refund = $this->participantRefunds->getByToken($refundToken);
+
+        $acceptRequest = new AcceptRefundRequest(
+            refund: $refund,
+            accountOwner: (string) $request->input('accountOwner'),
+            accountIban: (string) $request->input('accountIban'),
+            declarationAccepted: $request->boolean('declarationAccepted'),
+        );
+
+        $response = new AcceptRefundCommand($acceptRequest)->execute();
+
+        // Immer Status 200: der HttpClient des Frontends verwirft Antworten mit Fehlerstatus, die
+        // Feldfehler kämen dort nie an (siehe resources/js/components/HttpClient.js).
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+            'error_types' => $response->errorTypes,
+        ]);
+    }
+}

app/Domains/ParticipantRefund/Controllers/CancelRefundController.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Controllers;
+
+use App\Domains\ParticipantRefund\Actions\CancelRefund\CancelRefundCommand;
+use App\Domains\ParticipantRefund\Actions\CancelRefund\CancelRefundRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class CancelRefundController extends CommonController
+{
+    public function __invoke(string $refundToken, Request $request): JsonResponse
+    {
+        $refund = $this->participantRefunds->getByToken($refundToken);
+
+        // Der Token ist hier keine Berechtigung: abbrechen darf nur, wer die Veranstaltung auch
+        // verwalten kann. `getById()` prüft genau das.
+        if ($refund === null || $this->events->getById($refund->event_id) === null) {
+            abort(403, 'Zugriff verweigert.');
+        }
+
+        $response = new CancelRefundCommand(new CancelRefundRequest($refund))->execute();
+
+        return response()->json([
+            'status' => $response->success ? 'success' : 'error',
+            'message' => $response->message,
+        ]);
+    }
+}

app/Domains/ParticipantRefund/Controllers/RefundDocumentController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Controllers;
+
+use App\Domains\ParticipantRefund\Actions\CreateRefundDocument\CreateRefundDocumentCommand;
+use App\Domains\ParticipantRefund\Actions\CreateRefundDocument\CreateRefundDocumentRequest;
+use App\Scopes\CommonController;
+use Illuminate\Http\Response;
+
+class RefundDocumentController extends CommonController
+{
+    public function __invoke(string $refundToken): Response
+    {
+        $refund = $this->participantRefunds->getByToken($refundToken);
+
+        // Der Beleg enthält die Bankverbindung -- er gehört der Aktionsleitung, nicht dem Token.
+        if ($refund === null || $this->events->getById($refund->event_id) === null) {
+            abort(403, 'Zugriff verweigert.');
+        }
+
+        $documentResponse = new CreateRefundDocumentCommand(new CreateRefundDocumentRequest($refund))->execute();
+
+        if (!$documentResponse->success) {
+            abort(422, $documentResponse->message ?? 'Der Beleg konnte nicht erstellt werden.');
+        }
+
+        return response($documentResponse->pdfContent, 200, [
+            'Content-Type' => 'application/pdf',
+            'Content-Disposition' => 'attachment; filename="' . $documentResponse->filename . '"',
+        ]);
+    }
+}

app/Domains/ParticipantRefund/Controllers/RefundPageController.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Domains\ParticipantRefund\Controllers;
+
+use App\Domains\ParticipantRefund\Actions\AcceptRefund\AcceptRefundCommand;
+use App\Models\ParticipantRefund;
+use App\Providers\InertiaProvider;
+use App\Scopes\CommonController;
+use Inertia\Response;
+
+/**
+ * Die öffentliche Seite, auf der der Teili seine Bankverbindung hinterlegt.
+ *
+ * Liefert ausschließlich Anzeigedaten -- niemals die bereits erfasste Bankverbindung: der Token wandert
+ * durch ein Postfach, und was einmal eingetragen ist, muss von dort nicht wieder herauslesbar sein.
+ */
+class RefundPageController extends CommonController
+{
+    public function __invoke(string $refundToken): Response
+    {
+        $refund = $this->participantRefunds->getByToken($refundToken);
+
+        return new InertiaProvider('ParticipantRefund/RefundPage', $this->props($refund))->render();
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function props(?ParticipantRefund $refund): array
+    {
+        // Unbekannt und abgebrochen sind für den Teili derselbe Zustand: es gibt nichts zu tun.
+        if ($refund === null || $refund->status === ParticipantRefund::STATUS_CANCELLED) {
+            return [
+                'state' => 'unavailable',
+                'message' => AcceptRefundCommand::NO_OPEN_REFUND,
+            ];
+        }
+
+        $participant = $refund->participant;
+        $event = $refund->event;
+
+        $common = [
+            'token' => $refund->token,
+            'name' => $participant->getNicename(),
+            'eventTitle' => $event->name,
+            'eventEmail' => $event->email,
+            'amount' => $refund->amount?->toString() ?? '0,00 Euro',
+            'reason' => $refund->reasonLabel(),
+            'reasonNote' => $refund->reason_note,
+        ];
+
+        if ($refund->isAccepted()) {
+            return array_merge($common, [
+                'state' => 'accepted',
+                'acceptedAt' => $refund->accepted_at?->format('d.m.Y'),
+            ]);
+        }
+
+        return array_merge($common, ['state' => 'open']);
+    }
+}