Fix #71: Echtzeitüberweisung im Überweisungsdialog

Der Überweisungsdialog bietet das Häkchen „Echtzeitüberweisung“. SEPA
behandelt sie als eigenes Verfahren: Über FinTS geht der Auftrag als HKIPZ
(SendSEPARealtimeTransfer) statt als HKCCS hinaus, die pain.001-Nachricht
trägt die Zahlungsart LclInstrm/Cd = INST (nur im ISO-Format
pain.001.001.03). Eine Echtzeitüberweisung hat keinen Ausführungstermin;
bietet die Bank sie nicht an, scheitert der Auftrag mit klarer Meldung,
eine stille Umwandlung in eine gewöhnliche Überweisung ist abgeschaltet.

Neue Spalte zahlungsauftraege.echtzeit (Migration 019), Test 43 und ein
E2E-Test für das Sperren des Termins.

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

Changes.md

@@ -1,5 +1,25 @@
 # Änderungen
 
+## Echtzeitüberweisung im Zahlungsverkehr (25.09.2026)
+
+Der Überweisungsdialog bietet jetzt das Häkchen **Echtzeitüberweisung**: Das Geld ist binnen
+Sekunden beim Empfänger. SEPA behandelt die Echtzeitüberweisung als eigenes Verfahren
+(SCT Inst), der Finanzmanager deshalb auch.
+
+- Über FinTS geht der Auftrag als Geschäftsvorfall HKIPZ hinaus (`SendSEPARealtimeTransfer`
+  aus php-fints) statt als HKCCS. In der pain.001-Nachricht steht die Zahlungsart
+  `LclInstrm/Cd = INST`; das gibt es nur im ISO-Format `pain.001.001.03`.
+- Eine Echtzeitüberweisung hat keinen Ausführungstermin: Der Dialog sperrt das Feld, ein
+  Termin in der Zukunft wird beim Speichern abgewiesen.
+- Bietet die Bank keine Echtzeitüberweisung an, scheitert der Auftrag mit einer klaren
+  Meldung und bleibt stehen. Eine stille Umwandlung in eine gewöhnliche Überweisung durch
+  die Bank ist abgeschaltet.
+- Die Übersicht kennzeichnet Echtzeitüberweisungen in der Spalte „Ausführung“, das
+  Übermittlungsprotokoll nennt sie ausdrücklich.
+- Neue Spalte `zahlungsauftraege.echtzeit` (Migration `019`).
+- Test 43 (`tests/43_EchtzeitueberweisungTest.php`) und ein E2E-Test für das Sperren des
+  Termins.
+
 ## Übermittlungsprotokoll für Überweisungen und Bankkommunikation (21.09.2026)
 
 Als Nachweis gegenüber der Bank, dass eine Überweisung fristgerecht und korrekt übermittelt

README.md

@@ -44,7 +44,7 @@ Haushalt wird beides parallel genutzt.
   eines wählbaren Zeitraums.
 * **Nebenmodule** – Buchungsvorlagen, regelmäßige Buchungen mit Fälligkeitslauf und
   Finanzkalender, Erinnerungen, Adressen, Verträge, Sparziele, Kredite mit Tilgungsplan.
-* **Zahlungsverkehr** – Überweisungen und Terminüberweisungen über FinTS.
+* **Zahlungsverkehr** – Überweisungen, Terminüberweisungen und Echtzeitüberweisungen über FinTS.
 * **Abgleich mit dem Bargeld-Tool** – wer Bargeldausgaben in einem zweiten Programm
   erfasst, sieht beim Zuweisen einer Kategorie sofort, ob die Buchung dort schon steht:
   grüner Haken, rotes X oder Ausrufezeichen in einer schmalen Spalte des Kontoblatts.

docs/nebenmodule.md

@@ -131,6 +131,17 @@ Fehlgeschlagene tragen die Meldung der Bank daneben.
 Ohne Ausführungstermin geht die Überweisung sofort hinaus, mit Termin als
 Terminüberweisung; sie erscheint dann im Finanzkalender.
 
+**Echtzeitüberweisung.** Das Häkchen „Echtzeitüberweisung“ im Überweisungsdialog
+(Spalte `zahlungsauftraege.echtzeit`) macht aus dem Auftrag eine SEPA-Echtzeitüberweisung
+(SCT Inst): Das Geld ist binnen Sekunden beim Empfänger. SEPA behandelt sie als eigenes
+Verfahren – über FinTS geht sie als Geschäftsvorfall **HKIPZ** hinaus statt als HKCCS, in
+der pain.001-Nachricht steht zusätzlich die Zahlungsart `PmtTpInf/LclInstrm/Cd = INST`.
+Einen Ausführungstermin gibt es dafür nicht; der Dialog sperrt das Feld, das Modell weist
+einen Termin in der Zukunft ab. Bietet die Bank keine Echtzeitüberweisung an (kein
+Segment HIIPZS in den Bankparametern), scheitert der Auftrag mit einer klaren Meldung.
+Eine Umwandlung in eine gewöhnliche Überweisung erlaubt der Finanzmanager der Bank
+ausdrücklich nicht – wer Echtzeit wählt, soll erfahren, wenn es nicht klappt.
+
 **Welches Konto bei der Bank gemeint ist**, entscheidet dieselbe Zuordnung wie beim
 Umsatzabruf: die Zeile in `bank_konten`, die dem Konto zugewiesen ist (IBAN, ersatzweise
 Kontonummer). Die IBAN am Konto selbst ist optional und wird nur herangezogen, wenn keine
@@ -147,6 +158,8 @@ anderen nur das ältere DK-Format `pain.001.003.03` – und weisen alles andere
 Einreichen ab. Welche Formate eine Bank führt, steht in den Bankparametern (Segment
 HISPAS); `SepaXml::schemaWaehlen()` sucht daraus das passende aus, ISO bevorzugt. Für die
 Einzelüberweisung sind beide Fassungen im Aufbau gleich, es genügt der andere Namensraum.
+Die Echtzeitüberweisung gibt es nur im ISO-Format: Das DK-Format kennt die Zahlungsart
+`LclInstrm` nicht. Ihre Formate nennt die Bank in HIIPZS, ersatzweise gelten die aus HISPAS.
 
 Der **SEPA-Zeichenvorrat** ist eng: `a–z A–Z 0–9 / - ? : ( ) . , ' +` und Leerzeichen.
 Umlaute werden umgeschrieben (ä → ae), alles Übrige fällt weg. Ohne diese Umschrift weist

migrations/019_echtzeitueberweisung.sql

@@ -0,0 +1,11 @@
+-- Echtzeitüberweisung (SEPA Instant Credit Transfer).
+--
+-- Eine Echtzeitüberweisung ist im SEPA-Verfahren ein eigener Geschäftsvorfall:
+-- Über FinTS geht sie als HKIPZ statt als HKCCS hinaus, und in der
+-- pain.001-Nachricht steht die Zahlungsart INST. Sie wird sofort ausgeführt,
+-- einen Ausführungstermin gibt es dafür nicht.
+--
+-- Idempotent über IF NOT EXISTS.
+
+ALTER TABLE zahlungsauftraege
+    ADD COLUMN IF NOT EXISTS echtzeit TINYINT(1) NOT NULL DEFAULT 0 AFTER ausfuehrung_am;

public/static/app.js

@@ -192,6 +192,22 @@
         });
     }
 
+    // Echtzeitüberweisung: Sie geht sofort hinaus, ein Ausführungstermin hat
+    // daneben keinen Sinn. Das Feld wird gesperrt, solange sie gewählt ist –
+    // die Prüfung beim Speichern bleibt trotzdem die maßgebliche.
+    const echtzeit = document.querySelector('[data-echtzeit]');
+    const termin   = document.getElementById('ausfuehrung_am');
+    if (echtzeit && termin) {
+        const abgleichen = function () {
+            termin.disabled = echtzeit.checked;
+            if (echtzeit.checked) {
+                termin.value = '';
+            }
+        };
+        echtzeit.addEventListener('change', abgleichen);
+        abgleichen();
+    }
+
     // Kontenzuordnung einer Bankverbindung: Die Felder für ein neues Konto
     // stehen in einer eigenen Tabellenzeile und werden erst sichtbar, wenn
     // „neues Konto anlegen“ gewählt ist. Ausgeblendet wird hier und nicht im

src/Controllers/ZahlungsverkehrController.php

@@ -303,6 +303,7 @@ class ZahlungsverkehrController extends BaseController
             'waehrung'   => $this->post('waehrung', 'EUR'),
             'verwendungszweck' => $this->post('verwendungszweck'),
             'ausfuehrung_am'   => $this->post('ausfuehrung_am'),
+            'echtzeit'         => isset($_POST['echtzeit']),
             'kategorie_id'     => $this->post('kategorie_id'),
             'klasse_id'        => $this->post('klasse_id'),
         ];

src/Models/Zahlungsauftrag.php

@@ -11,7 +11,9 @@ use Finanzmanager\Mandant;
  * Überweisungen: erfasst, geprüft, über FinTS abgesendet.
  *
  * Der Auftrag bleibt als Beleg stehen, auch wenn die Bank ihn ablehnt – mit der
- * Meldung daneben. Erst wenn die Bank ihn angenommen hat, entsteht die
+ * Meldung daneben. Eine Überweisung geht als gewöhnliche Überweisung,
+ * Terminüberweisung oder Echtzeitüberweisung hinaus; die Echtzeitüberweisung
+ * behandelt SEPA als eigenen Geschäftsvorfall und kennt keinen Termin. Erst wenn die Bank ihn angenommen hat, entsteht die
  * zugehörige Buchung auf dem Auftragskonto; vorher wäre sie eine Behauptung.
  */
 class Zahlungsauftrag
@@ -63,12 +65,12 @@ class Zahlungsauftrag
         Database::execute(
             'INSERT INTO zahlungsauftraege
                 (benutzer_id, konto_id, zugang_id, empfaenger, iban, bic, betrag, waehrung,
-                 verwendungszweck, ausfuehrung_am, kategorie_id, klasse_id, status)
+                 verwendungszweck, ausfuehrung_am, echtzeit, kategorie_id, klasse_id, status)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
             [
                 Mandant::id(), $f['konto_id'], $f['zugang_id'], $f['empfaenger'], $f['iban'],
                 $f['bic'], $f['betrag'], $f['waehrung'], $f['verwendungszweck'],
-                $f['ausfuehrung_am'], $f['kategorie_id'], $f['klasse_id'], 'entwurf',
+                $f['ausfuehrung_am'], $f['echtzeit'], $f['kategorie_id'], $f['klasse_id'], 'entwurf',
             ]
         );
 
@@ -91,12 +93,12 @@ class Zahlungsauftrag
         Database::execute(
             'UPDATE zahlungsauftraege SET konto_id = ?, zugang_id = ?, empfaenger = ?, iban = ?,
                     bic = ?, betrag = ?, waehrung = ?, verwendungszweck = ?, ausfuehrung_am = ?,
-                    kategorie_id = ?, klasse_id = ?, status = \'entwurf\', meldung = NULL
+                    echtzeit = ?, kategorie_id = ?, klasse_id = ?, status = \'entwurf\', meldung = NULL
               WHERE id = ? AND benutzer_id = ?',
             [
                 $f['konto_id'], $f['zugang_id'], $f['empfaenger'], $f['iban'], $f['bic'],
                 $f['betrag'], $f['waehrung'], $f['verwendungszweck'], $f['ausfuehrung_am'],
-                $f['kategorie_id'], $f['klasse_id'], $id, Mandant::id(),
+                $f['echtzeit'], $f['kategorie_id'], $f['klasse_id'], $id, Mandant::id(),
             ]
         );
     }
@@ -209,6 +211,15 @@ class Zahlungsauftrag
             throw new \InvalidArgumentException('Der Ausführungstermin liegt in der Vergangenheit.');
         }
 
+        // Eine Echtzeitüberweisung ist binnen Sekunden beim Empfänger – einen
+        // Termin kennt sie nicht. Der heutige Tag ist ohnehin „sofort“.
+        $echtzeit = !empty($daten['echtzeit']);
+        if ($echtzeit && $termin !== '' && $termin > date('Y-m-d')) {
+            throw new \InvalidArgumentException(
+                'Eine Echtzeitüberweisung wird sofort ausgeführt und kann keinen Ausführungstermin haben.'
+            );
+        }
+
         $id = static fn(mixed $wert): ?int =>
             ($wert === null || $wert === '' || (int)$wert === 0) ? null : (int)$wert;
 
@@ -223,7 +234,8 @@ class Zahlungsauftrag
             // 140 Zeichen sind das SEPA-Maß für den Verwendungszweck; was
             // darüber steht, würde die Bank ohnehin abschneiden.
             'verwendungszweck' => mb_substr(trim((string)($daten['verwendungszweck'] ?? '')), 0, 140),
-            'ausfuehrung_am'   => $termin !== '' ? $termin : null,
+            'ausfuehrung_am'   => $termin !== '' && !$echtzeit ? $termin : null,
+            'echtzeit'         => $echtzeit ? 1 : 0,
             'kategorie_id'     => $id($daten['kategorie_id'] ?? null),
             'klasse_id'        => $id($daten['klasse_id'] ?? null),
         ];

src/Services/FinTsUeberweisung.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Finanzmanager\Services;
 
 use Fhp\Action\GetSEPAAccounts;
+use Fhp\Action\SendSEPARealtimeTransfer;
 use Fhp\Action\SendSEPATransfer;
 use Fhp\BaseAction;
 use Fhp\FinTs;
@@ -14,6 +15,8 @@ use Fhp\Model\VopConfirmationRequest;
 use Fhp\Model\VopVerificationResult;
 use Fhp\Options\Credentials;
 use Fhp\Options\FinTsOptions;
+use Fhp\Segment\IPZ\HIIPZSv1;
+use Fhp\Segment\IPZ\HIIPZSv2;
 use Fhp\Segment\SPA\HISPAS;
 use Finanzmanager\Auth;
 use Finanzmanager\Models\Bankprotokoll;
@@ -40,6 +43,13 @@ use Finanzmanager\Models\Zahlungsauftrag;
  * überein, geht es ohne Rückfrage weiter zur TAN. Weicht der Name ab oder konnte
  * die Bank nicht prüfen, wird zuerst gefragt – mit dem Text, den die Bank dazu
  * mitliefert.
+ *
+ * **Echtzeitüberweisung.** Ist sie am Auftrag gewählt, geht der Auftrag als
+ * eigener Geschäftsvorfall HKIPZ hinaus statt als HKCCS – so will es das
+ * SEPA-Verfahren. Bietet die Bank das nicht an, scheitert der Auftrag mit einer
+ * klaren Meldung und bleibt stehen. Eine stille Umwandlung in eine gewöhnliche
+ * Überweisung erlauben wir der Bank nicht: Wer Echtzeit wählt, braucht das Geld
+ * sofort beim Empfänger und soll erfahren, wenn das nicht klappt.
  */
 class FinTsUeberweisung
 {
@@ -185,7 +195,8 @@ class FinTsUeberweisung
         $auftrag = Zahlungsauftrag::find($this->auftragId);
         if ($auftrag !== null) {
             $this->mitschnitt->vermerke(sprintf(
-                'Überweisung %d: %s, IBAN %s, %s %s, Ausführung %s',
+                '%s %d: %s, IBAN %s, %s %s, Ausführung %s',
+                self::istEchtzeit($auftrag) ? 'Echtzeitüberweisung' : 'Überweisung',
                 $this->auftragId,
                 $auftrag['empfaenger'],
                 $auftrag['iban'],
@@ -307,17 +318,29 @@ class FinTsUeberweisung
                     return $this->fehler('Das Auftragskonto ist nicht mehr lesbar. Bitte erneut senden.');
                 }
 
-                $formate = $this->sepaFormate($fints);
+                $echtzeit = self::istEchtzeit($auftrag);
-                $schema  = SepaXml::schemaWaehlen($formate);
+                if ($echtzeit && $this->echtzeitParameter($fints) === null) {
+                    return $this->fehler(
+                        'Die Bank bietet über FinTS keine Echtzeitüberweisung an. '
+                        . 'Bitte die Echtzeitüberweisung am Auftrag abwählen und erneut senden.'
+                    );
+                }
+
+                $formate = $echtzeit ? $this->echtzeitFormate($fints) : $this->sepaFormate($fints);
+                $schema  = SepaXml::schemaWaehlen($formate, $echtzeit);
                 if ($schema === null) {
                     return $this->fehler(
-                        'Die Bank nimmt nur SEPA-Formate an, die der Finanzmanager nicht erzeugt: '
+                        ($echtzeit ? 'Für Echtzeitüberweisungen nimmt die Bank' : 'Die Bank nimmt')
+                        . ' nur SEPA-Formate an, die der Finanzmanager nicht erzeugt: '
                         . implode(', ', $formate)
                     );
                 }
 
                 $xml    = SepaXml::ueberweisung($this->auftragsdaten($auftrag, $sepa), $schema);
-                $aktion = SendSEPATransfer::create($sepa, $xml);
+                $aktion = $echtzeit
+                    // Keine Umwandlung in eine gewöhnliche Überweisung – siehe oben.
+                    ? SendSEPARealtimeTransfer::create($sepa, $xml, false)
+                    : SendSEPATransfer::create($sepa, $xml);
                 $fints->execute($aktion);
 
                 return $this->nachDemSenden($fints, $aktion);
@@ -352,6 +375,42 @@ class FinTsUeberweisung
             : [];
     }
 
+    /**
+     * Die Bankparameter der Echtzeitüberweisung (Segment HIIPZS) – oder `null`,
+     * wenn die Bank sie über FinTS nicht anbietet.
+     */
+    private function echtzeitParameter(FinTs $fints): HIIPZSv1|HIIPZSv2|null
+    {
+        try {
+            $hiipzs = $fints->getBpd()->getLatestSupportedParameters('HIIPZS');
+        } catch (\Throwable) {
+            return null;
+        }
+
+        return $hiipzs instanceof HIIPZSv1 || $hiipzs instanceof HIIPZSv2 ? $hiipzs : null;
+    }
+
+    /**
+     * Die SEPA-Datenformate für Echtzeitüberweisungen. Nennt die Bank dafür
+     * keine eigenen, gelten die allgemeinen aus HISPAS.
+     *
+     * @return list<string>
+     */
+    private function echtzeitFormate(FinTs $fints): array
+    {
+        $formate = $this->echtzeitParameter($fints)?->parameter->getUnterstuetzteSEPADatenformate();
+
+        return $formate === null || $formate === []
+            ? $this->sepaFormate($fints)
+            : array_values($formate);
+    }
+
+    /** @param array<string,mixed> $auftrag */
+    private static function istEchtzeit(array $auftrag): bool
+    {
+        return (int)($auftrag['echtzeit'] ?? 0) === 1;
+    }
+
     /**
      * Was nach dem Einreichen des Auftrags noch zu tun ist: auf den
      * Namensabgleich warten, ihn bestätigen lassen, die TAN einholen.
@@ -428,6 +487,7 @@ class FinTsUeberweisung
             'waehrung'        => (string)$auftrag['waehrung'],
             'verwendungszweck' => (string)$auftrag['verwendungszweck'],
             'ausfuehrung_am'  => $auftrag['ausfuehrung_am'],
+            'echtzeit'        => self::istEchtzeit($auftrag),
         ];
     }
 
@@ -488,7 +548,13 @@ class FinTsUeberweisung
     /** @return array<string,mixed> */
     private function angenommen(FinTs $fints): array
     {
-        Zahlungsauftrag::alsGesendetVermerken($this->auftragId, 'Von der Bank angenommen.');
+        $auftrag  = Zahlungsauftrag::find($this->auftragId);
+        $echtzeit = $auftrag !== null && self::istEchtzeit($auftrag);
+
+        Zahlungsauftrag::alsGesendetVermerken(
+            $this->auftragId,
+            $echtzeit ? 'Von der Bank als Echtzeitüberweisung angenommen.' : 'Von der Bank angenommen.'
+        );
         self::vergessen();
 
         try {
@@ -497,7 +563,12 @@ class FinTsUeberweisung
             // Der Dialog ist zu Ende; ein Fehler beim Abmelden ändert nichts.
         }
 
-        return ['status' => 'erfolg', 'meldung' => 'Die Überweisung wurde an die Bank übergeben.'];
+        return [
+            'status'  => 'erfolg',
+            'meldung' => $echtzeit
+                ? 'Die Echtzeitüberweisung wurde an die Bank übergeben.'
+                : 'Die Überweisung wurde an die Bank übergeben.',
+        ];
     }
 
     /**

src/Services/SepaXml.php

@@ -18,6 +18,12 @@ namespace Finanzmanager\Services;
  * Fassungen im Aufbau gleich (Reihenfolge und Pflichtfelder stimmen überein),
  * sie unterscheiden sich nur im Namensraum. Welches Format die Bank annimmt,
  * steht im FinTS-Segment HISPAS – siehe `Services\FinTsUeberweisung`.
+ *
+ * **Echtzeitüberweisung.** SEPA behandelt sie als eigenes Verfahren (SCT Inst):
+ * In der Nachricht steht zusätzlich die Zahlungsart `LclInstrm/Cd = INST`, und
+ * die Bank bekommt sie über einen eigenen Geschäftsvorfall (HKIPZ). Das ältere
+ * DK-Format pain.001.003.03 kennt die Zahlungsart nicht – eine
+ * Echtzeitüberweisung gibt es deshalb nur im ISO-Format.
  */
 class SepaXml
 {
@@ -27,6 +33,12 @@ class SepaXml
     /** Die Formate, die hier erzeugt werden – in der Reihenfolge des Vorzugs. */
     private const SCHEMATA = [self::SCHEMA_PAIN_001_001_03, self::SCHEMA_PAIN_001_003_03];
 
+    /** Die Formate, in denen sich eine Echtzeitüberweisung ausdrücken lässt. */
+    private const SCHEMATA_ECHTZEIT = [self::SCHEMA_PAIN_001_001_03];
+
+    /** Zahlungsart (Local Instrument) der Echtzeitüberweisung. */
+    public const ECHTZEIT = 'INST';
+
     /**
      * Das Ausführungsdatum für „sofort“.
      *
@@ -44,7 +56,7 @@ class SepaXml
      *     absender_name: string, absender_iban: string, absender_bic?: string,
      *     empfaenger_name: string, empfaenger_iban: string, empfaenger_bic?: string,
      *     betrag: float, waehrung?: string, verwendungszweck?: string,
-     *     ausfuehrung_am?: ?string
+     *     ausfuehrung_am?: ?string, echtzeit?: bool
      * } $auftrag
      * @param string $schema Namensraum der Nachricht, siehe `schemaWaehlen()`.
      */
@@ -55,12 +67,20 @@ class SepaXml
             throw new \InvalidArgumentException('Der Betrag muss größer als null sein.');
         }
 
+        $echtzeit = !empty($auftrag['echtzeit']);
+        if ($echtzeit && !in_array($schema, self::SCHEMATA_ECHTZEIT, true)) {
+            throw new \InvalidArgumentException('Eine Echtzeitüberweisung gibt es nur im Format pain.001.001.03.');
+        }
+
         // Eindeutige Kennungen: Die Bank lehnt eine Nachricht ab, deren Kennung
         // sie schon kennt.
         $kennung = 'FM' . date('YmdHis') . substr(bin2hex(random_bytes(4)), 0, 6);
         $zeitpunkt = date('Y-m-d\TH:i:s');
 
-        $ausfuehrung = self::ausfuehrungstag((string)($auftrag['ausfuehrung_am'] ?? ''));
+        // Eine Echtzeitüberweisung geht immer sofort hinaus.
+        $ausfuehrung = $echtzeit
+            ? self::SOFORT
+            : self::ausfuehrungstag((string)($auftrag['ausfuehrung_am'] ?? ''));
 
         $waehrung = strtoupper((string)($auftrag['waehrung'] ?? 'EUR'));
         $zweck    = self::text((string)($auftrag['verwendungszweck'] ?? ''), 140);
@@ -100,6 +120,11 @@ class SepaXml
         $ebene = $dokument->createElement('SvcLvl');
         $art->appendChild($ebene);
         self::kind($dokument, $ebene, 'Cd', 'SEPA');
+        if ($echtzeit) {
+            $zahlungsart = $dokument->createElement('LclInstrm');
+            $art->appendChild($zahlungsart);
+            self::kind($dokument, $zahlungsart, 'Cd', self::ECHTZEIT);
+        }
 
         self::kind($dokument, $sammler, 'ReqdExctnDt', $ausfuehrung);
 
@@ -193,15 +218,18 @@ class SepaXml
      * Vorzugsformat; meldet sie nur Formate, die hier nicht erzeugt werden,
      * kommt `null` zurück.
      *
+     * Für eine Echtzeitüberweisung kommt nur das ISO-Format infrage; führt die
+     * Bank ausschließlich das DK-Format, ist das Ergebnis ebenfalls `null`.
+     *
      * @param list<string> $unterstuetzt
      */
-    public static function schemaWaehlen(array $unterstuetzt): ?string
+    public static function schemaWaehlen(array $unterstuetzt, bool $echtzeit = false): ?string
     {
         if ($unterstuetzt === []) {
             return self::SCHEMA_PAIN_001_001_03;
         }
 
-        foreach (self::SCHEMATA as $schema) {
+        foreach ($echtzeit ? self::SCHEMATA_ECHTZEIT : self::SCHEMATA as $schema) {
             foreach ($unterstuetzt as $format) {
                 if (str_starts_with(trim($format), $schema)) {
                     return $schema;

src/Views/zahlungsverkehr/formular.php

@@ -119,6 +119,17 @@ include __DIR__ . '/../layout/kopf.php';
     <input type="date" id="ausfuehrung_am" name="ausfuehrung_am"
            value="<?= View::h($wert('ausfuehrung_am')) ?>">
 
+    <label class="ankreuzfeld">
+        <input type="checkbox" id="echtzeit" name="echtzeit" value="1" data-echtzeit
+            <?= (int)$wert('echtzeit', '0') === 1 ? 'checked' : '' ?>>
+        Echtzeitüberweisung
+    </label>
+    <p class="feldhinweis">
+        Das Geld ist binnen Sekunden beim Empfänger. Eine Echtzeitüberweisung wird sofort
+        ausgeführt und hat keinen Ausführungstermin. Bietet die Bank sie nicht an, wird der
+        Auftrag abgewiesen und bleibt als Entwurf stehen.
+    </p>
+
     <label for="kategorie_id">Kategorie</label>
     <select id="kategorie_id" name="kategorie_id">
         <option value="">– keine –</option>

src/Views/zahlungsverkehr/index.php

@@ -40,7 +40,7 @@ include __DIR__ . '/../layout/kopf.php';
 <p class="hinweis">
     Eine Überweisung wird erst gebucht, wenn die Bank sie angenommen hat – vorher steht sie
     als Entwurf hier. Ohne Ausführungstermin geht sie sofort hinaus, mit Termin als
-    Terminüberweisung.
+    Terminüberweisung, als Echtzeitüberweisung binnen Sekunden.
 </p>
 
 <?php if ($auftraege === []): ?>
@@ -66,9 +66,13 @@ include __DIR__ . '/../layout/kopf.php';
                 <td><?= View::h($auftrag['kontoname']) ?></td>
                 <td class="rechts negativ"><?= View::betrag($auftrag['betrag']) ?></td>
                 <td>
-                    <?= $auftrag['ausfuehrung_am'] === null
+                    <?php if ((int)($auftrag['echtzeit'] ?? 0) === 1): ?>
-                        ? '<span class="nebentext">sofort</span>'
+                        <span class="marke" title="Echtzeitüberweisung">Echtzeit</span>
-                        : View::h(View::datum($auftrag['ausfuehrung_am'])) ?>
+                    <?php else: ?>
+                        <?= $auftrag['ausfuehrung_am'] === null
+                            ? '<span class="nebentext">sofort</span>'
+                            : View::h(View::datum($auftrag['ausfuehrung_am'])) ?>
+                    <?php endif; ?>
                 </td>
                 <td>
                     <?php if ((int)$auftrag['protokolle'] > 0): ?>

tests/43_EchtzeitueberweisungTest.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+use Finanzmanager\Database;
+use Finanzmanager\Models\Bankprotokoll;
+use Finanzmanager\Models\Bankzugang;
+use Finanzmanager\Models\Konto;
+use Finanzmanager\Models\Zahlungsauftrag;
+use Finanzmanager\Services\FinTsUeberweisung;
+use Finanzmanager\Services\SepaXml;
+
+/**
+ * Echtzeitüberweisung (SEPA Instant Credit Transfer).
+ *
+ * SEPA behandelt sie als eigenes Verfahren: In der pain.001-Nachricht steht die
+ * Zahlungsart INST, über FinTS geht sie als HKIPZ hinaus, und einen
+ * Ausführungstermin kennt sie nicht. Geprüft werden das Merkmal am Auftrag, die
+ * Nachricht und dass ein Sendeversuch als Echtzeitüberweisung protokolliert
+ * wird. Wie in Test 42 geht der Versuch an eine Adresse auf dem eigenen
+ * Rechner, auf der niemand lauscht.
+ */
+class EchtzeitueberweisungTest extends TestCase
+{
+    protected string $testName = 'Test 43: Echtzeitüberweisung';
+
+    private int $giro = 0;
+    private int $zugang = 0;
+
+    public function run(): void
+    {
+        $this->mandantAnlegen();
+        $this->stammdaten();
+
+        $this->dasMerkmalWirdGespeichert();
+        $this->einTerminVertraegtSichNichtMitEchtzeit();
+        $this->dieNachrichtTraegtDieZahlungsartInst();
+        $this->nurDasIsoFormatKenntEchtzeit();
+        $this->derSendeversuchNenntDieEchtzeitueberweisung();
+    }
+
+    private function stammdaten(): void
+    {
+        $this->giro = Konto::anlegen([
+            'name' => 'Echtzeit-Giro', 'kontoart' => 'bank', 'anfangssaldo' => 0, 'aktiv' => 1,
+        ]);
+
+        $this->zugang = Bankzugang::anlegen([
+            'name'            => 'Echtzeit-Bank',
+            'bankname'        => 'Echtzeit-Bank AG',
+            'blz'             => '12030000',
+            'fints_url'       => 'https://banking.example.org/fints',
+            'benutzerkennung' => 'testkunde',
+            'pin'             => 'geheim1234',
+            'abrufzeitraum'   => 'letzter_abruf',
+            'aktiv'           => 1,
+        ]);
+    }
+
+    /** @param array<string,mixed> $daten */
+    private function auftrag(array $daten = []): int
+    {
+        return Zahlungsauftrag::anlegen(array_merge([
+            'konto_id'   => $this->giro,
+            'zugang_id'  => $this->zugang,
+            'empfaenger' => 'Handwerker Schnell',
+            'iban'       => 'DE02120300000000202051',
+            'betrag'     => 250.0,
+            'echtzeit'   => true,
+        ], $daten));
+    }
+
+    private function dasMerkmalWirdGespeichert(): void
+    {
+        $id = $this->auftrag();
+        $this->assertEquals(1, (int)Zahlungsauftrag::find($id)['echtzeit'], 'Die Echtzeitüberweisung ist vermerkt');
+
+        $gewoehnlich = $this->auftrag(['echtzeit' => false]);
+        $this->assertEquals(0, (int)Zahlungsauftrag::find($gewoehnlich)['echtzeit'], 'Ohne Häkchen bleibt es eine gewöhnliche Überweisung');
+
+        Zahlungsauftrag::speichern($id, [
+            'konto_id'   => $this->giro,
+            'empfaenger' => 'Handwerker Schnell',
+            'iban'       => 'DE02120300000000202051',
+            'betrag'     => 250.0,
+        ]);
+        $this->assertEquals(0, (int)Zahlungsauftrag::find($id)['echtzeit'], 'Abwählen beim Bearbeiten wirkt');
+    }
+
+    private function einTerminVertraegtSichNichtMitEchtzeit(): void
+    {
+        $abgewiesen = false;
+        try {
+            $this->auftrag(['ausfuehrung_am' => date('Y-m-d', strtotime('+7 days'))]);
+        } catch (\InvalidArgumentException) {
+            $abgewiesen = true;
+        }
+        $this->assert($abgewiesen, 'Eine Echtzeitüberweisung mit Termin in der Zukunft wird abgewiesen');
+
+        $heute = $this->auftrag(['ausfuehrung_am' => date('Y-m-d')]);
+        $this->assertNull(
+            Zahlungsauftrag::find($heute)['ausfuehrung_am'],
+            'Der heutige Tag ist „sofort“ – der Termin fällt weg'
+        );
+    }
+
+    private function dieNachrichtTraegtDieZahlungsartInst(): void
+    {
+        $auftrag = [
+            'absender_name'    => 'Max Mustermann',
+            'absender_iban'    => 'DE02120300000000202051',
+            'empfaenger_name'  => 'Handwerker Schnell',
+            'empfaenger_iban'  => 'DE02500105170137075030',
+            'betrag'           => 250.0,
+            'verwendungszweck' => 'Rechnung 4711',
+            // Ein Termin wird bei Echtzeit nicht übernommen.
+            'ausfuehrung_am'   => '2099-09-05',
+            'echtzeit'         => true,
+        ];
+
+        $pfad = static function (string $xml): DOMXPath {
+            $dokument = new DOMDocument();
+            $dokument->loadXML($xml);
+            $xpath = new DOMXPath($dokument);
+            $xpath->registerNamespace('p', SepaXml::SCHEMA_PAIN_001_001_03);
+
+            return $xpath;
+        };
+
+        $xpath = $pfad(SepaXml::ueberweisung($auftrag));
+        $this->assertEquals(
+            SepaXml::ECHTZEIT,
+            $xpath->evaluate('string(//p:PmtInf/p:PmtTpInf/p:LclInstrm/p:Cd)'),
+            'Die Zahlungsart INST steht in der Nachricht'
+        );
+        $this->assertEquals(
+            'LclInstrm',
+            $xpath->evaluate('local-name(//p:PmtTpInf/p:SvcLvl/following-sibling::*[1])'),
+            'Die Zahlungsart folgt unmittelbar auf die Service-Ebene, wie das Schema es verlangt'
+        );
+        $this->assertEquals(
+            SepaXml::SOFORT,
+            $xpath->evaluate('string(//p:PmtInf/p:ReqdExctnDt)'),
+            'Eine Echtzeitüberweisung geht immer sofort hinaus'
+        );
+
+        $auftrag['echtzeit'] = false;
+        $this->assertEquals(
+            0.0,
+            $pfad(SepaXml::ueberweisung($auftrag))->evaluate('count(//p:LclInstrm)'),
+            'Eine gewöhnliche Überweisung trägt keine Zahlungsart'
+        );
+    }
+
+    private function nurDasIsoFormatKenntEchtzeit(): void
+    {
+        $this->assertNull(
+            SepaXml::schemaWaehlen([SepaXml::SCHEMA_PAIN_001_003_03], true),
+            'Führt die Bank nur das DK-Format, gibt es keine Echtzeitüberweisung'
+        );
+        $this->assertEquals(
+            SepaXml::SCHEMA_PAIN_001_001_03,
+            SepaXml::schemaWaehlen([SepaXml::SCHEMA_PAIN_001_003_03, SepaXml::SCHEMA_PAIN_001_001_03 . '_GBIC_4'], true),
+            'Sonst wird das ISO-Format genommen'
+        );
+
+        $abgewiesen = false;
+        try {
+            SepaXml::ueberweisung([
+                'absender_name'   => 'Max Mustermann',
+                'absender_iban'   => 'DE02120300000000202051',
+                'empfaenger_name' => 'Handwerker Schnell',
+                'empfaenger_iban' => 'DE02500105170137075030',
+                'betrag'          => 1.0,
+                'echtzeit'        => true,
+            ], SepaXml::SCHEMA_PAIN_001_003_03);
+        } catch (\InvalidArgumentException) {
+            $abgewiesen = true;
+        }
+        $this->assert($abgewiesen, 'Eine Echtzeitüberweisung im DK-Format wird nicht erzeugt');
+    }
+
+    private function derSendeversuchNenntDieEchtzeitueberweisung(): void
+    {
+        // Auf dem eigenen Rechner lauscht niemand – der Versuch scheitert sofort.
+        Database::execute(
+            'UPDATE bank_zugaenge SET fints_url = ? WHERE id = ?',
+            ['http://127.0.0.1:9/fints', $this->zugang]
+        );
+
+        $id       = $this->auftrag();
+        $ergebnis = FinTsUeberweisung::senden($id);
+        FinTsUeberweisung::abbrechen();
+
+        $this->assertEquals('fehler', $ergebnis['status'], 'Ohne erreichbare Bank scheitert das Senden');
+        $this->assertEquals('fehler', Zahlungsauftrag::find($id)['status'], 'Der Auftrag bleibt als fehlgeschlagen stehen');
+
+        $eintraege = Bankprotokoll::fuerAuftrag($id);
+        $this->assert(
+            $eintraege !== [] && str_contains((string)$eintraege[0]['protokoll'], 'Echtzeitüberweisung'),
+            'Das Übermittlungsprotokoll nennt die Echtzeitüberweisung'
+        );
+    }
+}

tests/e2e/specs/module.spec.js

@@ -310,6 +310,21 @@ test.describe('Module der Phasen 4 bis 7', () => {
 		await expect(page.locator('.meldung-fehler')).toContainText('IBAN')
 	})
 
+	test('Die Echtzeitüberweisung sperrt den Ausführungstermin', async ({ page }) => {
+		await page.goto('/zahlungsverkehr/neu')
+
+		await page.fill('#ausfuehrung_am', '2099-09-05')
+		await page.check('#echtzeit')
+
+		// Eine Echtzeitüberweisung geht sofort hinaus – der Termin wird geleert
+		// und gesperrt, solange sie gewählt ist.
+		await expect(page.locator('#ausfuehrung_am')).toBeDisabled()
+		await expect(page.locator('#ausfuehrung_am')).toHaveValue('')
+
+		await page.uncheck('#echtzeit')
+		await expect(page.locator('#ausfuehrung_am')).toBeEnabled()
+	})
+
 	test('Eine Überweisung übernimmt den Empfänger auf Wunsch ins Adressbuch', async ({ page }) => {
 		const empfaenger = `E2E-Adressbuch ${Date.now()}`