From 6f9aa469435133982fee1adb0610934cacde4ed4 Mon Sep 17 00:00:00 2001 From: Lars Date: Tue, 3 Nov 2026 14:03:17 +0100 Subject: [PATCH] v0.11: Umsetzungsbericht, Abnahme-Drehbuch, Status; InboxTest wiederhergestellt MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Umsetzungsergebnis mit Rückverfolgung CH-01–18, S1–S6, E-032–038, M01–M12, Entscheidungen, Einschränkungen und Go-live-Bedingungen. - Abnahme auf dem Testsystem: benötigte Dienste, Testkonfiguration, Drehbuch ohne manuelle Ersatzschritte. - Der bestehende InboxTest (Postfach der Vermieterin) war versehentlich überschrieben worden; wiederhergestellt, die U5-Tests heißen jetzt GuestMailInboxTest. Co-Authored-By: Claude Opus 5.5 --- .../Abnahme/V011_ABNAHME_TESTSYSTEM.md | 58 +++++ .../UMSETZUNGSERGEBNIS_V011.md | 139 ++++++++++++ docs/STATUS.md | 34 ++- tests/Feature/GuestMailInboxTest.php | 194 +++++++++++++++++ tests/Feature/InboxTest.php | 205 +++++------------- 5 files changed, 473 insertions(+), 157 deletions(-) create mode 100644 docs/Prozessarchitektur/Abnahme/V011_ABNAHME_TESTSYSTEM.md create mode 100644 docs/Prozessarchitektur/Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md create mode 100644 tests/Feature/GuestMailInboxTest.php diff --git a/docs/Prozessarchitektur/Abnahme/V011_ABNAHME_TESTSYSTEM.md b/docs/Prozessarchitektur/Abnahme/V011_ABNAHME_TESTSYSTEM.md new file mode 100644 index 0000000..f134199 --- /dev/null +++ b/docs/Prozessarchitektur/Abnahme/V011_ABNAHME_TESTSYSTEM.md @@ -0,0 +1,58 @@ +# v0.11 – Fachliche Abnahme auf dem Testsystem (stommer.info) + +**Zweck:** Abnahme des integrierten v0.11-MVP ohne manuelle Ersatzschritte, im Testbetrieb. · **Voraussetzung:** Auslieferung des Stands aus `feature/aufenthalt` auf das Testsystem (nach Abstimmung mit dem Betreiber) und die externen Dienste aus §1. · Bericht: [Umsetzungsergebnis v0.11](../Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md) + +--- + +## 1. Benötigte externe Dienste (vom Betreiber bereitzustellen) + +| Dienst | Wofür | Einrichtung | +|---|---|---| +| **Eigenes IMAP-Postfach** für die Gästekommunikation, z. B. `anfragen@…` bei Strato | Antworten der Gäste und Portal-Mails lesen (CH-01, CH-05) | Zugangsdaten unter System › Betrieb; „Was wird gelesen?“ = „Alle Nachrichten“; „Adresse dieses Postfachs“ = die Postfachadresse. Das Postfach darf nur für Anfragen und Antworten dienen. | +| **SMTP** (wie bei T23) | Rückfragen und Angebote versenden | ist eingerichtet; Testbetrieb lässt nur die Testadresse zu | +| **KI-Zugang** (Anthropic API) | Auswertung der Antworten (CH-14) | Schlüssel als `FEWO_AI_API_KEY` in `shared/.env`, danach `bash scripts/deploy.sh staging artisan optimize`. Betreiberbereich › Mandant › Dienste: „KI: Gästekommunikation“ einschalten. | +| **Testpostfach**, das die Testadresse empfängt und von dem aus geantwortet werden kann | Rückfragen empfangen und beantworten | System › Betrieb › Testadresse | +| Scheduler (n8n, vorhanden) | `channels:fetch-mail` jede Minute, `cases:data-requests` und `messages:extract` alle fünf Minuten | läuft über den vorhandenen Auslöser; nichts zu tun | + +**Datenschutz im Test:** Es gehen echte Nachrichtentexte an den KI-Anbieter. Für die Abnahme bitte nur Testnachrichten ohne echte Gastdaten verwenden (Go-live-Bedingung G4/G5). + +## 2. Testkonfiguration + +1. **System › Betrieb:** + - Betriebsart „Testbetrieb“; + - Testadresse = Testpostfach; + - Postfach wie in §1. +2. **So arbeite ich:** + - Bearbeitung „Automatisch weiterbearbeiten“; + - „Wie wird nach fehlenden Angaben gefragt?“ = „Automatisch beim Gast nachfragen“; + - Dokumente: Rückfrage bleibt als Arbeitsfassung, im Testbetrieb geht sie trotzdem hinaus. +3. **Kanäle › Eigene Webseite:** zunächst nichts ändern, die Standards gelten. Für Fall 7 vorübergehend die Klärungsreservierung „automatisch“ auf `0` setzen. +4. **Kanäle › FeWo-direkt:** Absender der Buchungs-E-Mails eingetragen (z. B. `fewo-direkt.de`). +5. **Preise:** Für die Testzeiträume sind Saisons hinterlegt (Lücke Januar bis März 2027 vorher schließen, siehe Status vom 02.11.2026). +6. **Wirksame Einstellungen** (Expertenansicht) prüfen: In der Spalte „Eigene Webseite – Anfrage“ stehen 15 Minuten (automatisch) bzw. 180 Minuten (Freigabe) und der Rückfragemodus „Automatisch“. + +## 3. Drehbuch (etwa 90 Minuten) + +Bei jedem Fall gilt: Im Vorgang › Ablauf und im Verlauf muss sichtbar sein, was geschah. Alle Mails gehen nur an die Testadresse; der Verlauf vermerkt „im Testbetrieb an die Testadresse“. + +| # | Ablauf | Erwartung | +|---|---|---| +| **1** | Auf der Webseite anfragen: Name, E-Mail, **ohne Anschrift** (M01, M11). | Vorgang „Anfrage“, oben „Angaben für das Angebot vervollständigen“. Kalender für 15 Minuten belegt. Die Rückfrage-Mail nennt „zur Klärung bis vorläufig reserviert“ und „noch kein verbindliches Angebot“. Kein Angebot; auch „Angebot senden“ von Hand wird mit „fehlen noch Angaben“ abgelehnt. | +| **2** | Im Testpostfach auf die Rückfrage **antworten**: „Lindenallee 12, 10115 Berlin“ (M02 E-Mail, CH-13 Antwortbezug). | Spätestens nach einer Minute steht die Nachricht im Posteingang als „einem Vorgang zugeordnet“ (Testbetrieb markiert), die Erinnerung ruht. Nach höchstens fünf Minuten ist sie ausgewertet: Anschrift übernommen (Herkunft „aus einer Nachricht erkannt (KI)“). Das Land kam schon aus dem Formular. Danach geht automatisch das **Angebot** hinaus, Reservierung 48 Stunden. | +| **3** | Zweite Anfrage ohne Anschrift. Den **Link** „Angaben ergänzen“ öffnen, nur die Straße senden, dann den Rest; das Formular zweimal absenden; einen älteren Link öffnen (M02 Link, M03, M09). | Nach der Teilantwort kommt eine gezielte Folgefrage mit neuem Link; der alte Link sagt „nicht mehr aktuell“. Doppeltes Absenden erzeugt nichts doppelt. Danach geht das Angebot hinaus. | +| **4** | Dritte Anfrage ohne Anschrift; nicht antworten. Im Vorgang die nächste Erinnerung ablesen. Zum Abkürzen „Wie oft wird höchstens erinnert?“ = 1 und „Nach wie vielen Stunden …“ = 1 setzen (M08). | Nach einer Stunde kommt eine Erinnerung, nach einer weiteren Stunde die Aufgabe „Fehlende Angaben selbst beim Gast nachfragen“. Die Klärungsreservierung ist nach 15 Minuten abgelaufen und wurde durch nichts verlängert; der Vorgang bleibt offen. | +| **5** | Vom Testpostfach eine **neue Mail ohne Bezug** an das Postfach senden: „Haben Sie im Dezember frei?“ (M04). | Posteingang „zu klären“, kein Vorgang. „Als neue Anfrage anlegen“ erzeugt die Anfrage; sie fragt nach der Anschrift. | +| **6** | Auf eine Rückfrage antworten: „Telefon 0171 1234567. Können wir einen Tag länger bleiben?“ (M05, M06). | Telefon übernommen. Aufgabe „Änderungswunsch des Gastes prüfen“; der Zeitraum ist **unverändert**. Optional: Betreiber führt `php artisan ai:evaluate` aus und notiert die Rate übersehener Angaben. | +| **7** | Klärungsreservierung „automatisch“ der Webseite auf `0`, erneut ohne Anschrift anfragen (M11, M12). | Kein Kalendereintrag. Die Rückfrage sagt „noch nicht für Sie reserviert“, ohne Reservierungsbehauptung. Danach den Wert zurücksetzen. | +| **8** | Portalbuchung: FeWo-direkt-Buchungsmail an das Postfach weiterleiten bzw. die vorhandene Testmail aus T04 verwenden (M07, M12, E-036). | Wie bisher: Sperre bzw. Vorgang „Beim Portal fest gebucht“. Keine Klärungsreservierung, kein Angebot. Fehlt nur die Anschrift, heißt die Rückfrage „Ihre Buchung ist verbindlich bestätigt …“. iCal-Abgleich läuft unverändert. | +| **9** | **Regression v0.10:** Drehbuch der Gesamtabnahme v0.10 §8 in Kurzform (Annahme, Auskunft und Buchungswunsch, Ändern, Storno, Aufenthalt) (M10). | Unverändert; neu ist nur, dass Angebot und Wunschbestätigung die vollständige Anschrift verlangen. | + +## 4. Abnahmeprotokoll + +Je Fall festhalten: +- bestanden / nicht bestanden; +- Uhrzeit; +- Vorgangsnummer; +- gegebenenfalls ein Screenshot unter `Abnahme//`. + +Offene Befunde gehen in den Status. Die Freigabe zum Live-Betrieb setzt zusätzlich die Go-live-Bedingungen G1–G8 voraus (Umsetzungsergebnis §7). diff --git a/docs/Prozessarchitektur/Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md b/docs/Prozessarchitektur/Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md new file mode 100644 index 0000000..b722a91 --- /dev/null +++ b/docs/Prozessarchitektur/Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md @@ -0,0 +1,139 @@ +# Umsetzungsergebnis v0.11 – integrierter MVP + +**Stand:** 03.11.2026 · **Branch:** `feature/aufenthalt` · **Commits:** 799869c (U1), ccac78a (U2), 37f48de (U3), e4a3cb7 (U4), dff9e23 (U5), 4170e3b (U6), 73c0a71 (Integrationstest) + +**Status:** +- umgesetzt und automatisiert getestet; +- **noch nicht** auf dem Testsystem: Auslieferung, Postfach und KI-Schlüssel stimmt der Betreiber vorher ab; +- keine Produktivauslieferung, kein Merge nach `main`. + +Bezug: +- [Umsetzungsplan](V011_UMSETZUNGSPLAN.md) +- [Zielarchitektur](V011_TECHNISCHE_ZIELARCHITEKTUR.md) +- [Abnahme auf dem Testsystem](../Abnahme/V011_ABNAHME_TESTSYSTEM.md) +- normativ: [Communication Handler](../Querschnitt/Datenbeschaffung_und_Communication_Handler.md) + +--- + +## 1. Ergebnis in Kürze + +- Alle sechs Pakete sind umgesetzt; ein durchgehender Integrationstest deckt die ganze Kette ab: Website-Anfrage ohne Anschrift → Klärungsreservierung → Rückfrage per Mail → Antwort des Gastes per E-Mail → Zuordnung über den Antwortbezug → KI-Auswertung → Fakteneingang → automatisches Angebot mit unverändertem Angebots-Hold → Annahme → verbindliche Buchung. +- **Tests:** 759 grün, vorher 702. Neu sind 57 Tests in 7 Dateien; 11 bestehende Testdateien wurden angepasst (Anschriften in Testdaten, siehe §5). +- Die Architekturgrenzen sind eingehalten: + - keine zweite Ablaufsteuerung (`CaseAutomation`/`CaseActivities` bleiben führend); + - Angebots-Hold und Annahmefristen unverändert; + - iCal-Pfad und Portal-Schnellweg unverändert; + - extern verbindliche Buchungen bleiben verbindlich; + - die KI ändert nichts selbst. + - Ein Architekturtest prüft, dass nur die bestehenden Reservierungsschritte Fristen schreiben. + +## 2. Was gebaut wurde + +| Paket | Inhalt | Wichtigste Dateien | +|---|---|---| +| U1 | Webseite als Kanal (`channels.kind`), neue Prozessparameter, „Kanäle“ in der einfachen Ansicht, „Wirksame Einstellungen“ mit Webseiten-Spalte | `ProcessSetting`, `ProcessSettings::forWebsite`, `Channel`, `ChannelForm`, `ListChannels` | +| U2 | Angebots-Gate G2a (vor Angebot und Wunschbestätigung, nicht vor Auskunft), gemeinsamer Fakteneingang mit Herkunft (`case_facts`), Land als ISO-Code | `CaseRequirements`, `ContributeCaseFacts`, `CaseFact`, `DocumentComposer`, `SendOffer`, `DecideBookingWish` | +| U3 | Klärungsreservierung (`hold_purpose`), Ablauf ohne Vorgangsende, Angebot danach nur bei freiem Zeitraum | `RequestHold`, `CreateReservation`, `TakeOverPortalInquiry`, `ExpireReservations`, `Booking::clarificationState` | +| U4 | Beschaffungsvorgang mit Rückfrage, Folgefrage, Erinnerung, Grenzen; Mail nach tatsächlichem Sperrstatus; signierter Ergänzungslink | `RequestCaseData`, `DataRequest`, `DataRequested`, `GuestDataController`, `cases:data-requests` | +| U5 | Postfächer (`mailboxes`), Nachrichteneingang (`inbound_messages`), Zuordnung nach CH-13, „Posteingang“, Message-ID der ausgehenden Mails | `ReceiveInboundMessage`, `MessageMatcher`, `InboundMessageResource`, `MailboxReader::fetchAll`, `LogBookingMail` | +| U6 | KI-Kaskade (klein → Regeln → groß), Prompts v1, Schema, Vorschläge im Posteingang, Messbefehl | `ExtractMessageFacts`, `MessageExtractor`, `RiskAssessment`, `LlmClient`, `messages:extract`, `ai:evaluate` | + +**Migrationen** (alle rückwärtskompatibel, keine wurde auf einem Server ausgeführt): +- `2026_11_06_090000` Kanalart; +- `…100000` Faktenprotokoll, Hold-Zweck, `guests.country` ohne Standardwert; +- `…110000` Beschaffungsvorgänge und Message-ID; +- `…120000` Postfächer und Nachrichteneingang. + +## 3. Rückverfolgbarkeit + +| Anforderung | Umsetzung | Nachweis (Test) | +|---|---|---| +| **CH-01** IMAP-Eingang, Antworten erkennen | Postfachmodus „alle Nachrichten“, `ReceiveInboundMessage` | `GuestMailInboxTest::test_the_mailbox_is_kept_as_a_record_and_full_mode_reads_every_message`, `V011EndToEndTest` | +| **CH-02** Inhalte, auch unstrukturiert; E-Mail als Rückkanal | Extraktion aus Betreff und Text; Antwortadresse = eigenes Postfach | `MessageExtractionTest`, `V011EndToEndTest` | +| **CH-03** kontrollierte Ergänzung, kein blindes Überschreiben | `ContributeCaseFacts` (fehlend → übernehmen, abweichend → Prüfaufgabe, Vermieterin maßgeblich) | `CaseFactIntakeTest::test_missing_values_are_taken_over…` | +| **CH-04** regelbasierte Rückfragen je Modus | `RequestCaseData` automatisch / Freigabe / manuell | `DataRequestTest` (drei Modi) | +| **CH-05** Modell für mehrere Postfächer, eines aktiv | `mailboxes`, `Tenant::activeMailbox` | `GuestMailInboxTest` | +| **CH-06** Erfassen, Doppelverarbeitung, Klärungsansicht, keine Vorgänge aus allgemeinen Mails | `inbound_messages` (eindeutig je Message-ID), „Posteingang“ | `GuestMailInboxTest::test_a_message_is_stored_once…`, `…the_landlord_assigns_a_message_or_makes_a_new_request_of_it` | +| **CH-07/13** deterministische Zuordnung; Nummer allein kein Identitätsnachweis; ein offener Vorgang des Absenders allein genügt nicht | `MessageMatcher` | `GuestMailInboxTest` (Antwortbezug, Nummer + Absender, Absender + Wohnung + Zeitraum, mehrdeutig) | +| **CH-08** Portalparser bleiben | Portal-Absender laufen unverändert durch `ProcessPortalMail` | `GuestMailInboxTest::test_a_portal_notification_goes_through_the_unchanged_portal_path`, `PortalMailTest` unverändert grün | +| **CH-09/12** Portal-Mail mit Gastdaten, beliebige Reihenfolge | Portal-Mail mit Vorgangsbezug wird ausgewertet (Quelle Portal-Mail) | `CaseFactIntakeTest` (Portal ergänzt Personenzahl), `CaseIntakeTest` unverändert grün | +| **CH-10** keine pauschale Rangfolge | Regel je Feld und Phase statt Quellenrang | `CaseFactIntakeTest` | +| **CH-11** iCal-Abgleich unverändert | keine Änderung an Sync, Regeln, Export | Kanal- und Sync-Tests unverändert grün | +| **CH-14** zweistufige KI, Kritikalität im Programm, Konfidenz nicht maßgeblich | `RiskAssessment`, `ExtractMessageFacts` | `MessageExtractionTest` (Widerspruch trotz Konfidenz 0,99 → Prüfung, keine Übernahme) | +| **CH-15/16/17** Rückfrage, Folgefrage, Erinnerung; Zähler ohne Reset; Grenzen; eine offene Rückfrage | `DataRequest`, `RequestCaseData::answered/remindDue` | `DataRequestTest::test_reminders_follow_their_limit…`, `…partly_and_then_fully` | +| **CH-18** signierter, versionierter Link, Lesen schreibt nicht, idempotent | `GuestDataController` | `DataRequestTest::test_foreign_outdated_and_unsigned_links_change_nothing` | +| **S1–S6** | `RequestCaseData` (S1), `ReceiveInboundMessage` (S2), `MessageMatcher` und Extraktion (S3), `DataRequested` und Link (S4), `ContributeCaseFacts` (S5), `CaseAutomation::advance` (S6) | `V011EndToEndTest` | +| **E-032 / G2a** Pflichtangaben, Anschrift nicht übergehbar | `CaseRequirements`, Blocker in `SendOffer`, `AutoOffer`, `DocumentComposer`, `DecideBookingWish` | `CaseFactIntakeTest` (M01, B3, B4) | +| **E-033 / G1a** Klärungsreservierung 15/180 min, `0` | `RequestHold` | `ClarificationHoldTest` | +| **E-034** Texte nach tatsächlichem Sperrstatus | `DataRequested`, Eingangsbestätigung, Linkseite | `DataRequestTest::test_the_texts_follow_the_real_state_of_the_hold` | +| **E-035** gemeinsamer Fakteneingang, KI nur Kandidaten | `ContributeCaseFacts`, `ExtractMessageFacts` | `MessageExtractionTest` | +| **E-036** extern verbindliche Buchung geschützt | nie Klärungsreservierung; Rückfrage nur administrativ | `ClarificationHoldTest`, `DataRequestTest`, `V011EndToEndTest` | +| **E-037** zentraler Kanalmanager | „Kanäle“ mit Webseite und Portalen | `ChannelManagerTest` | +| **E-038** Änderungswunsch nur erfassen | Aufgabe „Änderungswunsch prüfen“, Buchung unverändert | `CaseFactIntakeTest` (M06-Kern), `MessageExtractionTest::test_a_wish_to_change_the_stay_is_only_a_request` | +| **B1–B4** (Betreiber 03.11.2026) | wie entschieden | `ClarificationHoldTest`, `CaseFactIntakeTest` | + +### Abnahmefälle M01–M12 + +| M | Automatisiert | Auf dem Testsystem | +|---|---|---| +| M01 | `CaseFactIntakeTest::test_a_request_without_address_gets_no_offer…` | Drehbuch Fall 1 | +| M02 | `DataRequestTest` (Link, teilweise und vollständig), `V011EndToEndTest` (E-Mail) | Fälle 2, 3 | +| M03 | `CaseFactIntakeTest`, `DataRequestTest` (doppeltes Absenden), `GuestMailInboxTest` (gleiche Mail) | Fall 3 | +| M04 | `GuestMailInboxTest` | Fall 5 | +| M05 | `MessageExtractionTest`, `ai:evaluate` | Fall 6 (Messlauf mit echtem Modell) | +| M06 | `MessageExtractionTest`, `CaseFactIntakeTest` | Fall 6 | +| M07 | `GuestMailInboxTest` (Portalpfad), `CaseIntakeTest` | Fall 8 | +| M08 | `DataRequestTest` | Fall 4 | +| M09 | `DataRequestTest` | Fall 3 | +| M10 | `GuestMailInboxTest`, `V011EndToEndTest`, `MailTestModeGateTest` | alle Fälle (Testbetrieb) | +| M11 | `DataRequestTest`, `ClarificationHoldTest` | Fall 1 und 7 | +| M12 | `ChannelManagerTest`, `V011EndToEndTest` | Fälle 7 und 8 | + +## 4. Technische Entscheidungen in der Umsetzung + +Sie stehen in der freigegebenen Zielarchitektur oder präzisieren sie. + +1. **Webseite als Kanal:** + - Je Wohnung gibt es einen Eintrag `kind = website`, nur für Einstellungen. + - `active()` und `Property::channels()` liefern nur Portale. Damit bleibt der Eintrag aus Sync, Export, Überwachung und Sperraufgaben heraus. + - Telefon- und E-Mail-Anfragen haben bewusst keinen eigenen Kanal; für sie gelten die Mandantenstandards (R02). +2. **Land:** + - `guests.country` hatte den Datenbankstandard „DE“. Neue Gäste haben jetzt kein Land, bis eine Quelle es nennt (B4). + - Bestehende Gäste behalten ihr „DE“, weil sich nicht feststellen lässt, ob es bestätigt war. +3. **Keine Rückfrage ohne E-Mail-Adresse:** Der Vorgang zeigt „Kontaktdaten eintragen“. Sobald die Adresse eingetragen ist, startet die Rückfrage nach dem, was noch fehlt. +4. **Rückfragetexte:** eigene Dokumentart „Rückfrage nach fehlenden Angaben“. Im Live-Betrieb geht sie ohne Freigabe nicht automatisch hinaus, sondern wartet auf einen Klick. Im Testbetrieb geht sie hinaus, aber nur an die Testadresse; so verhält sich auch das automatische Angebot. +5. **Antwortadresse:** Rückfragen nennen das eigene Postfach als Antwortadresse, wenn es im Modus „alle Nachrichten“ läuft. Alle anderen Mails behalten die bisherige Antwortadresse. +6. **Zuordnung direkter Gast-Mails:** + - Absender + Wohnung + beide Termine eines einzigen offenen Vorgangs. + - Hat der Mandant nur eine Wohnung, ist die Wohnung damit bestimmt. Bei mehreren muss der Wohnungsname in der Nachricht stehen. +7. **Portalanfragen (A2) ohne Gastdaten** reservieren beim Eingang nichts mehr: B1 gilt auch für sie. Die Angebots-Reservierung entsteht wie bisher mit dem Angebot. +8. **KI:** + - Kleines Modell `claude-haiku-5-5`, Prüfmodell `claude-opus-5-5`, beide per Konfiguration austauschbar. + - Für das Prüfmodell ist der serverseitige Fallback bei Ablehnung aktiv (`fallbacks: "default"`). Eine Ablehnung gilt trotzdem als Fehlschlag, und die Nachricht geht an die Vermieterin. + - Die Anbindung läuft laut Plan über den HTTP-Client. Ein offizielles PHP-SDK gibt es; seine Aufnahme wäre eine Abhängigkeitsänderung und bräuchte eine Freigabe. + - Die Prompt-Anweisungen sind englisch, Werte und Oberfläche deutsch. + - Bekannte Werte gehen nur maskiert an den Anbieter. +9. **Takt:** Postfach jede Minute (Rückblick drei Tage, Deduplizierung je Message-ID), Erinnerungen und Auswertung alle fünf Minuten. Die Auswertung blockiert den Portal-Schnellweg also nicht. +10. **Kontaktdialog der Vermieterin:** Die Daten laufen über den Fakteneingang. Der Schalter „automatisch weitermachen“ behält seine bisherige Fortsetzungslogik, weil sie Portalbuchungen bindet. Konflikt K2 ist damit gelöst; die Doppelung der Fortsetzung (Auditbefund L3) besteht nur noch an dieser einen Stelle. + +## 5. Anpassungen bestehender Tests + +- **11 bestehende Testdateien:** + - 10 erhielten in ihren Testdaten eine vollständige Anschrift mit Land, weil Angebote sie jetzt voraussetzen (G2a). Die Prüfaussagen blieben gleich. + - `TenantSettingsTest` kennt den neuen verdrahteten Dienst. +- Keine bestehende Prüfaussage wurde abgeschwächt. + +## 6. Einschränkungen + +- **Nicht real geprüft:** IMAP gegen ein echtes Postfach und Aufrufe des echten KI-Dienstes. Automatisiert sind beide ersetzt (Mock, HTTP-Fake). Die echte Integrationsprüfung gehört zur Abnahme auf dem Testsystem. +- **Kalibrierung:** Der mitgelieferte Messsatz hat erst 4 Nachrichten. Schwellen (Eskalation 0,2, Mindestkonfidenz 0,85) und Prompt v1 sind Startwerte. +- **Texte** der Rückfrage, Folgefrage, Erinnerung und der Linkseite sind Arbeitsfassungen ohne rechtliche Freigabe. +- **Aufbewahrung:** Nachrichtentexte und Faktwerte sind verschlüsselt gespeichert, werden aber noch nicht vom Anonymisierungslauf erfasst. Eine Löschfrist ist nicht beschlossen. +- **API-Schlüssel je Mandant:** Das Datenfeld ist vorhanden, eine Oberfläche nicht. Auf dem Testsystem gilt `FEWO_AI_API_KEY`. +- **Postfach-Zugangsdaten** werden auf „System › Betrieb“ gepflegt und in den Postfach-Datensatz übernommen. Die alten Mandantenspalten bleiben bis zur Produktivmigration als Rückfall. +- **Plus-Adressen** werden nicht genutzt; die Zuordnung läuft über Message-ID und Vorgangsnummer. +- Nicht Teil des MVP laut v0.11: parallele Angebote, automatische Vertragsänderungen und Teilstorno, mehrere aktive Postfächer, Messenger, generative Antworten, Gastkonto. + +## 7. Go-live-Bedingungen + +G1 Texte rechtlich freigeben · G2 endgültige Werte je Kanal (Rückfragemodus, Intervalle, Grenzen, Klärungsminuten) · G3 eigenes Postfach je Mandant, Zustellung der Antworten geprüft · G4 Datenschutz: Lesen aller Mails, Lösch- und Aufbewahrungsfristen inklusive Nachrichteneingang, Datenschutzhinweise · G5 KI-Anbieter: Auftragsverarbeitung, Speicherort, Kosten · G6 Kalibrierung mit repräsentativen anonymisierten Nachrichten, Rate übersehener Angaben akzeptiert · G7 Kriterien für verlässliche Portal-Mails · G8 Sicherheitsprüfung von Gastlink und Posteingang; Abnahme M01–M12 auf dem Testsystem; Regression v0.10. diff --git a/docs/STATUS.md b/docs/STATUS.md index 6f730de..5006253 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -1,6 +1,37 @@ # Projektstand -## Aktueller Stand (02.11.2026) +## Aktueller Stand (03.11.2026) + +**Prozessarchitektur v0.11: integrierter MVP umgesetzt (Pakete U1–U6), automatisiert getestet, noch nicht auf dem Testsystem.** + +| Branch | Inhalt | Stand | +|---|---|---| +| `main` | Produktion | unverändert | +| `develop` (Testsystem stommer.info) | v0.10 Pakete 1–9, Korrekturen vom 02.11. | ausgeliefert | +| `feature/aufenthalt` | zusätzlich v0.11-Spezifikation, Planung und MVP U1–U6 | **nicht** gemergt oder ausgeliefert; Auslieferung, Postfach und KI-Schlüssel stimmt der Betreiber vorher ab | + +- **Kanalmanager:** „Kanäle“ mit eigener Webseite und Portalen; neue Einstellungen für Klärungsreservierung (15/180 min, 0 = keine), Rückfragemodus, Erinnerungen, Folgefragen, Linkgültigkeit, Anschrift im Formular. +- **Angebots-Gate:** Vor Angebot und Wunschbestätigung braucht es Name, E-Mail, vollständige Anschrift mit Land, Personenzahl und Zeitraum; das lässt sich nicht übergehen. Die Auskunft bleibt ohne Gate. +- **Fakteneingang:** jede Angabe mit Herkunft (`case_facts`); Abweichungen des Gastes werden Prüfaufgaben, Zeitraum und Personenzahl nur Änderungswünsche. +- **Klärungsreservierung** für unvollständige Anfragen; der Angebots-Hold ist unverändert. +- **Datenbeschaffung:** Rückfrage, Folgefrage, Erinnerung, signierter Ergänzungslink; Texte nach tatsächlichem Sperrstatus. +- **Posteingang:** eigenes Postfach im Modus „alle Nachrichten“, Zuordnung nach CH-13, Klärungsansicht. +- **KI-Auswertung:** kleines Modell → Regeln → Prüfmodell; nur geprüfte Angaben gehen über den Fakteneingang. Der Dienst ist je Mandant standardmäßig aus. +- **Tests:** 759 grün. + +Dokumente: +- [Umsetzungsergebnis v0.11](Prozessarchitektur/Implementierungsstände/UMSETZUNGSERGEBNIS_V011.md) (Rückverfolgung, Entscheidungen, Einschränkungen, Go-live-Bedingungen); +- [Abnahme auf dem Testsystem](Prozessarchitektur/Abnahme/V011_ABNAHME_TESTSYSTEM.md) (Dienste, Konfiguration, Drehbuch); +- Planung: [Soll-Ist](Prozessarchitektur/Implementierungsstände/V011_SOLL_IST_ANALYSE.md), [Zielarchitektur](Prozessarchitektur/Implementierungsstände/V011_TECHNISCHE_ZIELARCHITEKTUR.md), [Umsetzungsplan](Prozessarchitektur/Implementierungsstände/V011_UMSETZUNGSPLAN.md). + +**Nächste Schritte:** +1. Abstimmung mit dem Betreiber: Auslieferung von `feature/aufenthalt` über `develop` auf das Testsystem (vier neue Migrationen), eigenes IMAP-Postfach, KI-Schlüssel (`FEWO_AI_API_KEY`). +2. Fachliche Abnahme nach dem Drehbuch, danach die Go-live-Bedingungen G1–G8. +3. Weiterhin aus v0.10: echte Mietbedingungen und Bank, Rechtsprüfung, Bedienprobe. + +## Verlauf (historisch, neueste zuerst) + +**Stand 02.11.2026:** **Prozessarchitektur v0.10: Pakete 1–9 umgesetzt.** @@ -26,7 +57,6 @@ ## Aktueller Stand (02.11.2026) 2. Echte Mietbedingungen und Bank eintragen, Texte freigeben, Rechtsprüfung der Gastschritte. 3. Bedienprobe mit der Vermieterin. -## Verlauf (historisch, neueste zuerst) **Pakete 8, 5 und 6 der Prozessarchitektur v0.10 (01.11.2026, Branch `feature/abwicklung`, nicht ausgeliefert):** **Beträge und Zahlungen** – Zahlungen mit Art (Gast an uns / laut Portal ans Portal / Auszahlung Portal / Erstattung), Portalbeträge als Angaben mit Quelle (`case_amounts`), Übersicht `App\Pricing\CaseMoney` trennt Gastforderung, Portalzahlung, Auszahlung und Kontoeingang; R09 exakt erfassbar. **Ändern und Beenden** – `ChangeBooking` mit Folgenvorschau, „mit dem Gast vereinbart“ (Grundlage, Zeitpunkt) oder „dem Gast vorschlagen“ (signierter Link, Annahme mit Nachweis); ein Stornoweg mit Initiator, Grund, Kosten- und Erstattungsaufgabe; Portalbuchungen erst storniert, wenn im Portal bestätigt. **A6** – Eigene Nutzung, Besuch und Sperre als Vorgang („Neu“, Belegungsplan „+ eintragen“), Kurabgabe als Position (Satz an der Wohnung), Aufenthaltsbestätigung ohne Mietvertrag, keine Mahnung/Bewertung/Marketing; Altsperren per `cases:adopt-blocks` (Vorschau, `--apply`, `--revert`, Export identisch). **System › Wirksame Einstellungen** zeigt je Eingangsweg und Vorgang die angewandten Werte. **685 Tests grün** (inkl. Abnahmekatalog T01–T14). Dokumente: [UMSETZUNGSERGEBNIS_P5_P6_P8](Prozessarchitektur/UMSETZUNGSERGEBNIS_P5_P6_P8.md), [END_TO_END_ABNAHME](Prozessarchitektur/END_TO_END_ABNAHME.md), [KONFIGURATION_UND_WIRKSAMKEIT](Prozessarchitektur/KONFIGURATION_UND_WIRKSAMKEIT.md). diff --git a/tests/Feature/GuestMailInboxTest.php b/tests/Feature/GuestMailInboxTest.php new file mode 100644 index 0000000..c5321ce --- /dev/null +++ b/tests/Feature/GuestMailInboxTest.php @@ -0,0 +1,194 @@ +travelTo(CarbonImmutable::parse('2026-10-22 10:00')); + $this->seed([PropertySeeder::class, SiteSeeder::class]); + $this->property = Property::sole(); + Mail::fake(); + Http::fake(['*' => Http::response('', 500)]); + } + + public function test_a_reply_to_our_mail_is_assigned_and_stops_the_reminders(): void + { + Settings::tenant()->update(['process_defaults' => ['data_request_mode' => 'automatic']]); + $booking = $this->request(); + BookingMessage::query()->create(['booking_id' => $booking->id, 'audience' => 'test', 'subject' => 'Rückfrage', 'message_id' => '', 'sent_at' => now()]); + + $message = $this->receive(from: 'irgendwer@example.org', subject: 'Re: Ihre Anfrage', text: 'Strandweg 1, 18225 Kühlungsborn', inReplyTo: ''); + + $this->assertSame([InboundMessage::ASSIGNED, $booking->id, 'reply'], [$message->status, $message->booking_id, $message->match_reason]); + $this->assertNull($booking->openDataRequest()->next_reminder_at, 'the answer stops the reminder'); + $this->assertSame(1, BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::InboundReview)->count()); + $this->assertTrue($message->test_mode, 'arrived in test operation'); + } + + public function test_the_case_number_counts_only_with_the_guest_as_sender(): void + { + $booking = $this->request(); + + $own = $this->receive(from: 'gesa@example.org', subject: 'Frage zu '.$booking->reference, text: 'Hallo'); + $foreign = $this->receive(from: 'fremd@example.org', subject: 'Frage zu '.$booking->reference, text: 'Hallo', id: '<2@x>'); + + $this->assertSame([InboundMessage::ASSIGNED, 'reference_and_sender'], [$own->status, $own->match_reason]); + $this->assertSame(InboundMessage::NEEDS_REVIEW, $foreign->status); + $this->assertSame($booking->id, $foreign->hints[0]['booking_id']); + } + + /** CH-13 as specified: one open case of the same sender alone is not enough. */ + public function test_a_direct_guest_mail_needs_sender_property_and_dates(): void + { + $booking = $this->request(); + + $vague = $this->receive(from: 'gesa@example.org', subject: 'Unsere Reise', text: 'Wir freuen uns schon!'); + $precise = $this->receive(from: 'gesa@example.org', subject: 'Unsere Reise', text: 'Für den Aufenthalt vom 07.11.2026 bis 10.11.2026 noch eine Frage.', id: '<3@x>'); + + $this->assertSame(InboundMessage::NEEDS_REVIEW, $vague->status); + $this->assertSame('offener Vorgang dieses Absenders (07.11.–10.11.2026)', $vague->hints[0]['why']); + $this->assertSame([InboundMessage::ASSIGNED, $booking->id, 'sender_property_dates'], [$precise->status, $precise->booking_id, $precise->match_reason]); + } + + public function test_dates_of_two_cases_of_the_same_guest_are_resolved_only_when_unambiguous(): void + { + $first = $this->request(); + $second = $this->request(arrival: '2026-11-20', departure: '2026-11-23'); + + $one = $this->receive(from: 'gesa@example.org', subject: 'Frage', text: 'Zum 20.11.2026 – 23.11.2026: Bringen wir den Hund mit?'); + $both = $this->receive(from: 'gesa@example.org', subject: 'Frage', text: '07.11.2026 bis 10.11.2026 und 20.11.2026 bis 23.11.2026', id: '<4@x>'); + + $this->assertSame($second->id, $one->booking_id); + $this->assertSame(InboundMessage::NEEDS_REVIEW, $both->status); + $this->assertNotSame($first->id, $one->booking_id); + } + + public function test_a_message_is_stored_once_and_our_own_mails_are_ignored(): void + { + $this->receive(from: 'gast@example.org', subject: 'Hallo', text: 'Test'); + $this->receive(from: 'gast@example.org', subject: 'Hallo', text: 'Test'); + $own = $this->receive(from: (string) config('mail.from.address'), subject: 'Kopie', text: 'x', id: ''); + + $this->assertSame(2, InboundMessage::query()->count()); + $this->assertSame(InboundMessage::IGNORED, $own->status); + } + + /** CH-08: the portal path stays as it is. */ + public function test_a_portal_notification_goes_through_the_unchanged_portal_path(): void + { + Channel::factory()->for($this->property)->create(['name' => 'FeWo-direkt', 'settings' => ['email_senders' => 'fewo-direkt.de']]); + + $message = $this->receive(from: 'noreply@fewo-direkt.de', subject: 'Neue Buchung', text: "Anreise: 07.12.2026\nAbreise: 14.12.2026\nBuchungsnummer: HA-1"); + + $portal = PortalEmail::query()->sole(); + $this->assertSame([InboundMessage::PORTAL, $portal->id], [$message->status, $message->portal_email_id]); + $this->assertSame($message->id, $portal->inbound_message_id); + $this->assertNotNull($portal->blocked_period_id, 'the booking was blocked as before'); + } + + /** M04: a general message creates nothing; the landlord decides in the inbox. */ + public function test_the_landlord_assigns_a_message_or_makes_a_new_request_of_it(): void + { + $this->actingAs(User::factory()->create()); + $booking = $this->request(); + $general = $this->receive(from: 'neu@example.org', subject: 'Haben Sie im Dezember frei?', text: 'Wir sind zwei Personen.'); + $other = $this->receive(from: 'unbekannt@example.org', subject: 'Nachtrag', text: 'Bitte zuordnen', id: '<5@x>'); + $this->assertSame(1, Booking::query()->count(), 'no case from a message by itself'); + + Livewire::test(ListInboundMessages::class) + ->callAction(TestAction::make('assign')->table($other), ['booking_id' => $booking->id]) + ->callAction(TestAction::make('createInquiry')->table($general), ['property_id' => $this->property->id, 'arrival' => '2026-12-01', 'departure' => '2026-12-05', 'guests' => 2, 'first_name' => 'Nina', 'last_name' => 'Neu', 'email' => 'neu@example.org']); + + $this->assertSame([InboundMessage::ASSIGNED, $booking->id], [$other->fresh()->status, $other->fresh()->booking_id]); + $created = Booking::query()->where('source', 'email')->sole(); + $this->assertSame([InboundMessage::PROCESSED, $created->id], [$general->fresh()->status, $general->fresh()->booking_id]); + $this->assertNotNull($created->openDataRequest(), 'the new request asks for its missing address'); + } + + public function test_our_mails_keep_their_message_id_for_replies(): void + { + config(['mail.default' => 'array']); + Settings::tenant()->update(['test_recipient' => 'test@example.org']); + Mail::swap(new MailManager($this->app)); + $booking = $this->request(); + $request = $booking->dataRequests()->create(['tenant_id' => $booking->tenant_id, 'status' => DataRequest::OPEN, 'mode' => 'automatic', 'purpose' => 'offer', 'fields' => ['guest.street']]); + + Mail::to('gesa@example.org')->send(new DataRequested($booking, $request, DataRequest::INITIAL, 'https://example.test')); + + $this->assertMatchesRegularExpression('/^<.+@.+>$/', (string) BookingMessage::query()->where('booking_id', $booking->id)->latest('id')->value('message_id')); + } + + public function test_the_mailbox_is_kept_as_a_record_and_full_mode_reads_every_message(): void + { + $this->actingAs(User::factory()->create()); + Livewire::test(Operations::class) + ->fillForm(['mailbox_host' => 'imap.example.org', 'mailbox_username' => 'anfragen@example.org', 'mailbox_password' => 'geheim', 'mailbox_mode' => Mailbox::FULL, 'mailbox_address' => 'anfragen@example.org']) + ->call('save')->assertHasNoFormErrors(); + $mailbox = Mailbox::query()->sole(); + $this->assertSame([Mailbox::FULL, 'anfragen@example.org', 'geheim'], [$mailbox->mode, $mailbox->address, $mailbox->password]); + $this->assertSame('anfragen@example.org', DataRequested::replyAddress(), 'questions ask for answers to this mailbox'); + + $reader = Mockery::mock(MailboxReader::class); + $reader->shouldReceive('fetchAll')->once()->andReturn([new PortalMail('<9@x>', 'gast@example.org', 'Hallo', 'Text', CarbonImmutable::now())]); + $this->app->instance(MailboxReader::class, $reader); + $this->artisan('channels:fetch-mail')->assertSuccessful(); + + $this->assertSame(InboundMessage::NEEDS_REVIEW, InboundMessage::query()->sole()->status); + $this->assertNotNull($mailbox->fresh()->last_fetched_at); + } + + private function request(string $arrival = '2026-11-07', string $departure = '2026-11-10'): Booking + { + return app(CreateReservation::class)->handle($this->property->fresh(), new StayRequest(CarbonImmutable::parse($arrival), CarbonImmutable::parse($departure), 2), ['first_name' => 'Gesa', 'last_name' => 'Gast', 'email' => 'gesa@example.org'])->fresh(); + } + + private function receive(string $from, string $subject, string $text, ?string $inReplyTo = null, string $id = '<1@x>'): InboundMessage + { + return app(ReceiveInboundMessage::class)->handle(new PortalMail($id, $from, $subject, $text, CarbonImmutable::now(), inReplyTo: $inReplyTo))->fresh(); + } +} diff --git a/tests/Feature/InboxTest.php b/tests/Feature/InboxTest.php index 84db681..3966530 100644 --- a/tests/Feature/InboxTest.php +++ b/tests/Feature/InboxTest.php @@ -2,193 +2,88 @@ namespace Tests\Feature; -use App\Actions\CreateReservation; -use App\Actions\ReceiveInboundMessage; -use App\Channels\Mail\MailboxReader; -use App\Channels\Mail\PortalMail; -use App\Enums\BookingTaskKind; -use App\Filament\Pages\Operations; -use App\Filament\Resources\InboundMessages\Pages\ListInboundMessages; -use App\Mail\DataRequested; -use App\Models\Booking; -use App\Models\BookingMessage; -use App\Models\BookingTask; +use App\Enums\InboxMessageKind; +use App\Filament\Resources\InboxMessages\InboxMessageResource; +use App\Filament\Resources\InboxMessages\Pages\ListInboxMessages; use App\Models\Channel; -use App\Models\DataRequest; -use App\Models\InboundMessage; -use App\Models\Mailbox; -use App\Models\PortalEmail; +use App\Models\InboxMessage; use App\Models\Property; use App\Models\User; -use App\Pricing\StayRequest; -use App\Support\Settings; -use Carbon\CarbonImmutable; -use Database\Seeders\PropertySeeder; -use Database\Seeders\SiteSeeder; +use App\Support\CurrentProperty; +use App\Support\Inbox; use Filament\Actions\Testing\TestAction; use Illuminate\Foundation\Testing\RefreshDatabase; -use Illuminate\Mail\MailManager; -use Illuminate\Support\Facades\Http; -use Illuminate\Support\Facades\Mail; use Livewire\Livewire; -use Mockery; use Tests\TestCase; -/** - * v0.11 package U5: the inbox of the guest communication mailbox – stored once, portal notifications through the - * unchanged portal path, deterministic assignment (CH-13) or clarification (M04), reply references (M07 part), - * test-mode mark (M10) and the landlord's clarification view. - */ class InboxTest extends TestCase { use RefreshDatabase; - private Property $property; + private Channel $channel; protected function setUp(): void { parent::setUp(); - $this->travelTo(CarbonImmutable::parse('2026-10-22 10:00')); - $this->seed([PropertySeeder::class, SiteSeeder::class]); - $this->property = Property::sole(); - Mail::fake(); - Http::fake(['*' => Http::response('', 500)]); - } - - public function test_a_reply_to_our_mail_is_assigned_and_stops_the_reminders(): void - { - Settings::tenant()->update(['process_defaults' => ['data_request_mode' => 'automatic']]); - $booking = $this->request(); - BookingMessage::query()->create(['booking_id' => $booking->id, 'audience' => 'test', 'subject' => 'Rückfrage', 'message_id' => '', 'sent_at' => now()]); - - $message = $this->receive(from: 'irgendwer@example.org', subject: 'Re: Ihre Anfrage', text: 'Strandweg 1, 18225 Kühlungsborn', inReplyTo: ''); - - $this->assertSame([InboundMessage::ASSIGNED, $booking->id, 'reply'], [$message->status, $message->booking_id, $message->match_reason]); - $this->assertNull($booking->openDataRequest()->next_reminder_at, 'the answer stops the reminder'); - $this->assertSame(1, BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::InboundReview)->count()); - $this->assertTrue($message->test_mode, 'arrived in test operation'); - } - - public function test_the_case_number_counts_only_with_the_guest_as_sender(): void - { - $booking = $this->request(); - - $own = $this->receive(from: 'gesa@example.org', subject: 'Frage zu '.$booking->reference, text: 'Hallo'); - $foreign = $this->receive(from: 'fremd@example.org', subject: 'Frage zu '.$booking->reference, text: 'Hallo', id: '<2@x>'); - - $this->assertSame([InboundMessage::ASSIGNED, 'reference_and_sender'], [$own->status, $own->match_reason]); - $this->assertSame(InboundMessage::NEEDS_REVIEW, $foreign->status); - $this->assertSame($booking->id, $foreign->hints[0]['booking_id']); - } - - /** CH-13 as specified: one open case of the same sender alone is not enough. */ - public function test_a_direct_guest_mail_needs_sender_property_and_dates(): void - { - $booking = $this->request(); - - $vague = $this->receive(from: 'gesa@example.org', subject: 'Unsere Reise', text: 'Wir freuen uns schon!'); - $precise = $this->receive(from: 'gesa@example.org', subject: 'Unsere Reise', text: 'Für den Aufenthalt vom 07.11.2026 bis 10.11.2026 noch eine Frage.', id: '<3@x>'); - - $this->assertSame(InboundMessage::NEEDS_REVIEW, $vague->status); - $this->assertSame('offener Vorgang dieses Absenders (07.11.–10.11.2026)', $vague->hints[0]['why']); - $this->assertSame([InboundMessage::ASSIGNED, $booking->id, 'sender_property_dates'], [$precise->status, $precise->booking_id, $precise->match_reason]); - } - - public function test_dates_of_two_cases_of_the_same_guest_are_resolved_only_when_unambiguous(): void - { - $first = $this->request(); - $second = $this->request(arrival: '2026-11-20', departure: '2026-11-23'); - - $one = $this->receive(from: 'gesa@example.org', subject: 'Frage', text: 'Zum 20.11.2026 – 23.11.2026: Bringen wir den Hund mit?'); - $both = $this->receive(from: 'gesa@example.org', subject: 'Frage', text: '07.11.2026 bis 10.11.2026 und 20.11.2026 bis 23.11.2026', id: '<4@x>'); - - $this->assertSame($second->id, $one->booking_id); - $this->assertSame(InboundMessage::NEEDS_REVIEW, $both->status); - $this->assertNotSame($first->id, $one->booking_id); - } - - public function test_a_message_is_stored_once_and_our_own_mails_are_ignored(): void - { - $this->receive(from: 'gast@example.org', subject: 'Hallo', text: 'Test'); - $this->receive(from: 'gast@example.org', subject: 'Hallo', text: 'Test'); - $own = $this->receive(from: (string) config('mail.from.address'), subject: 'Kopie', text: 'x', id: ''); - - $this->assertSame(2, InboundMessage::query()->count()); - $this->assertSame(InboundMessage::IGNORED, $own->status); - } - - /** CH-08: the portal path stays as it is. */ - public function test_a_portal_notification_goes_through_the_unchanged_portal_path(): void - { - Channel::factory()->for($this->property)->create(['name' => 'FeWo-direkt', 'settings' => ['email_senders' => 'fewo-direkt.de']]); - - $message = $this->receive(from: 'noreply@fewo-direkt.de', subject: 'Neue Buchung', text: "Anreise: 07.12.2026\nAbreise: 14.12.2026\nBuchungsnummer: HA-1"); - - $portal = PortalEmail::query()->sole(); - $this->assertSame([InboundMessage::PORTAL, $portal->id], [$message->status, $message->portal_email_id]); - $this->assertSame($message->id, $portal->inbound_message_id); - $this->assertNotNull($portal->blocked_period_id, 'the booking was blocked as before'); - } - - /** M04: a general message creates nothing; the landlord decides in the inbox. */ - public function test_the_landlord_assigns_a_message_or_makes_a_new_request_of_it(): void - { $this->actingAs(User::factory()->create()); - $booking = $this->request(); - $general = $this->receive(from: 'neu@example.org', subject: 'Haben Sie im Dezember frei?', text: 'Wir sind zwei Personen.'); - $other = $this->receive(from: 'unbekannt@example.org', subject: 'Nachtrag', text: 'Bitte zuordnen', id: '<5@x>'); - $this->assertSame(1, Booking::query()->count(), 'no case from a message by itself'); - - Livewire::test(ListInboundMessages::class) - ->callAction(TestAction::make('assign')->table($other), ['booking_id' => $booking->id]) - ->callAction(TestAction::make('createInquiry')->table($general), ['property_id' => $this->property->id, 'arrival' => '2026-12-01', 'departure' => '2026-12-05', 'guests' => 2, 'first_name' => 'Nina', 'last_name' => 'Neu', 'email' => 'neu@example.org']); - - $this->assertSame([InboundMessage::ASSIGNED, $booking->id], [$other->fresh()->status, $other->fresh()->booking_id]); - $created = Booking::query()->where('source', 'email')->sole(); - $this->assertSame([InboundMessage::PROCESSED, $created->id], [$general->fresh()->status, $general->fresh()->booking_id]); - $this->assertNotNull($created->openDataRequest(), 'the new request asks for its missing address'); + $this->channel = Channel::factory()->for(Property::factory())->create(['name' => 'FeWo-direkt']); } - public function test_our_mails_keep_their_message_id_for_replies(): void + public function test_a_finding_is_posted_only_once(): void { - config(['mail.default' => 'array']); - Settings::tenant()->update(['test_recipient' => 'test@example.org']); - Mail::swap(new MailManager($this->app)); - $booking = $this->request(); - $request = $booking->dataRequests()->create(['tenant_id' => $booking->tenant_id, 'status' => DataRequest::OPEN, 'mode' => 'automatic', 'purpose' => 'offer', 'fields' => ['guest.street']]); + $inbox = app(Inbox::class); - Mail::to('gesa@example.org')->send(new DataRequested($booking, $request, DataRequest::INITIAL, 'https://example.test')); + $first = $inbox->post(InboxMessageKind::ChannelConflict, 'x', 'Mögliche Doppelbuchung', 'Text', $this->channel); + $again = $inbox->post(InboxMessageKind::ChannelConflict, 'x', 'Mögliche Doppelbuchung', 'Text', $this->channel); - $this->assertMatchesRegularExpression('/^<.+@.+>$/', (string) BookingMessage::query()->where('booking_id', $booking->id)->latest('id')->value('message_id')); + $this->assertNotNull($first); + $this->assertNull($again); + $this->assertSame($this->channel->property_id, $first->property_id); + $this->assertSame(1, InboxMessage::count()); } - public function test_the_mailbox_is_kept_as_a_record_and_full_mode_reads_every_message(): void + public function test_menu_shows_the_number_of_unread_messages(): void { - $this->actingAs(User::factory()->create()); - Livewire::test(Operations::class) - ->fillForm(['mailbox_host' => 'imap.example.org', 'mailbox_username' => 'anfragen@example.org', 'mailbox_password' => 'geheim', 'mailbox_mode' => Mailbox::FULL, 'mailbox_address' => 'anfragen@example.org']) - ->call('save')->assertHasNoFormErrors(); - $mailbox = Mailbox::query()->sole(); - $this->assertSame([Mailbox::FULL, 'anfragen@example.org', 'geheim'], [$mailbox->mode, $mailbox->address, $mailbox->password]); - $this->assertSame('anfragen@example.org', DataRequested::replyAddress(), 'questions ask for answers to this mailbox'); + InboxMessage::factory()->for($this->channel)->count(2)->create(); + InboxMessage::factory()->for($this->channel)->read()->create(); - $reader = Mockery::mock(MailboxReader::class); - $reader->shouldReceive('fetchAll')->once()->andReturn([new PortalMail('<9@x>', 'gast@example.org', 'Hallo', 'Text', CarbonImmutable::now())]); - $this->app->instance(MailboxReader::class, $reader); - $this->artisan('channels:fetch-mail')->assertSuccessful(); - - $this->assertSame(InboundMessage::NEEDS_REVIEW, InboundMessage::query()->sole()->status); - $this->assertNotNull($mailbox->fresh()->last_fetched_at); + $this->assertSame('2', InboxMessageResource::getNavigationBadge()); + $this->get(InboxMessageResource::getUrl('index'))->assertOk()->assertSee('Postfach'); } - private function request(string $arrival = '2026-11-07', string $departure = '2026-11-10'): Booking + public function test_messages_can_be_marked_as_read_and_opened(): void { - return app(CreateReservation::class)->handle($this->property->fresh(), new StayRequest(CarbonImmutable::parse($arrival), CarbonImmutable::parse($departure), 2), ['first_name' => 'Gesa', 'last_name' => 'Gast', 'email' => 'gesa@example.org'])->fresh(); + $message = InboxMessage::factory()->for($this->channel)->create(['subject' => 'Mögliche Doppelbuchung über FeWo-direkt', 'action_url' => 'http://localhost/admin/belegung']); + $other = InboxMessage::factory()->for($this->channel)->create(); + + Livewire::test(ListInboxMessages::class) + ->assertCanSeeTableRecords([$message, $other]) + ->assertSee('Mögliche Doppelbuchung über FeWo-direkt') + ->callAction(TestAction::make('toggleRead')->table($other)) + ->callAction(TestAction::make('open')->table($message)) + ->assertRedirect('http://localhost/admin/belegung'); + + $this->assertTrue($message->fresh()->isRead()); + $this->assertTrue($other->fresh()->isRead()); + $this->assertNull(InboxMessageResource::getNavigationBadge()); } - private function receive(string $from, string $subject, string $text, ?string $inReplyTo = null, string $id = '<1@x>'): InboundMessage + public function test_read_all_marks_only_the_chosen_apartments_messages(): void { - return app(ReceiveInboundMessage::class)->handle(new PortalMail($id, $from, $subject, $text, CarbonImmutable::now(), inReplyTo: $inReplyTo))->fresh(); + $otherChannel = Channel::factory()->for(Property::factory())->create(); + $own = InboxMessage::factory()->for($this->channel)->create(['property_id' => $this->channel->property_id]); + $general = InboxMessage::factory()->create(['tenant_id' => $this->channel->tenant_id]); + $foreign = InboxMessage::factory()->for($otherChannel)->create(['property_id' => $otherChannel->property_id]); + app(CurrentProperty::class)->select($this->channel->property); + + Livewire::test(ListInboxMessages::class) + ->assertCanSeeTableRecords([$own, $general]) + ->assertCanNotSeeTableRecords([$foreign]) + ->callAction('readAll'); + + $this->assertTrue($own->fresh()->isRead()); + $this->assertTrue($general->fresh()->isRead()); + $this->assertFalse($foreign->fresh()->isRead()); } }