Compare commits

..
Author SHA1 Message Date
LarsandClaude Opus 5.5 7e4e208d18 Vorgang: Schritte im Ablauf anklickbar – was geschah, Herkunft der Angaben, korrigieren
Deploy FeWo mit PipelineManager / deploy (push) Successful in 5m13s
- Ein Klick auf einen Schritt im „Ablauf“ öffnet seine Einzelheiten: die
  Verlaufseinträge dieses Schritts und bei den Gastangaben jede Angabe mit
  Wert, Herkunft (Webseite, Link, E-Mail, KI, Sie), Zeitpunkt, Belegstelle,
  Sicherheit und offenen Abweichungen.
- „Angaben korrigieren“ öffnet den Eintragsdialog: Ihre Eingabe gilt, der
  vorherige Wert bleibt im Nachweis; „Diesen Schritt ausführen“ führt
  direkt zur Aktion des Schritts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 18:03:36 +01:00
LarsandClaude Opus 5.5 ad63db78f3 Posteingang: Antwortbezug ohne Klammern, Testadresse im Testbetrieb, sofortige Auswertung
Deploy FeWo mit PipelineManager / deploy (push) Successful in 5m6s
- Antwortbezug (In-Reply-To/References) wird mit und ohne spitze Klammern
  verglichen – Strato liefert ihn ohne, gespeichert war er mit; Antworten
  blieben deshalb im Posteingang hängen.
- Testbetrieb: Die Testadresse steht zusammen mit der genannten
  Vorgangsnummer für den Gast dieses Vorgangs (alle Antworten kommen vom
  Testpostfach). Im Live-Betrieb gilt das nicht.
- Eine zugeordnete Nachricht wird sofort ausgewertet (automatisch und nach
  Zuordnung von Hand), nicht erst im Fünf-Minuten-Lauf; die Meldung nennt,
  was übernommen wurde. Neu: „Erneut auswerten“.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 17:39:11 +01:00
LarsandClaude Opus 5.5 f4a435c71a Vorgang: fehlende Angaben selbst eintragen als nächster Schritt
Deploy FeWo mit PipelineManager / deploy (push) Successful in 5m4s
- Wartet der Vorgang auf die Antwort des Gastes, ist „Fehlende Angaben
  selbst eintragen“ der große Schalter (vorher leer, Dialog nur unter
  „Weitere Möglichkeiten“). Die Eingabe läuft über den Fakteneingang
  (Herkunft „von Ihnen eingetragen“); die Rückfrage endet, sobald alles
  da ist, im Automatikmodus geht das Angebot hinaus.
- Dialog verständlicher benannt: „Gast eintragen“ / „Fehlende Angaben
  selbst eintragen“ / „Gastdaten bearbeiten“.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 17:31:51 +01:00
LarsandClaude Opus 5.5 154b8a434c Postfach: Posteingang wird unter jedem Namen gefunden; kein doppeltes „SSL“
- MailboxReader::folder(): „Posteingang“, „Inbox“ oder leer → INBOX (so
  heißt der Posteingang auf dem IMAP-Server); andere Namen ohne Beachtung
  der Groß-/Kleinschreibung; unbekannter Ordner → Meldung mit den
  vorhandenen Ordnern statt „Call to a member function query() on null“.
  Gilt für Portal-Abruf, vollständigen Abruf und „Postfach prüfen“.
- Verschlüsselung: Platzhalter „Standard (SSL)“ statt eines zweiten „SSL“;
  Hinweis am Ordnerfeld.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 17:26:49 +01:00
LarsandClaude Opus 5.5 3a039e5c50 v0.11: Angebot wartet sichtbar auf Pflichtangaben; Postfach prüfen; Eingangsmails am Vorgang
Deploy FeWo mit PipelineManager / deploy (push) Successful in 5m10s
- Vorgang: „Angebot prüfen und senden“ wird erst angeboten, wenn alle
  Pflichtangaben da sind („erst wenn alle Angaben da sind“); ebenso wartet
  „Buchungswunsch bestätigen?“. Die harte Sperre in SendOffer, AutoOffer
  und DecideBookingWish bestand bereits; jetzt stimmt auch die Anzeige.
- System › Betrieb: „Postfach prüfen“ (Verbindung, Anzahl Nachrichten der
  letzten Tage, nichts wird gelesen oder markiert) und Stand des Abrufs.
- Posteingang zeigt letzten erfolgreichen Abruf und letzten Fehler.
- Vorgang: neuer Bereich „Eingegangene E-Mails“ mit Lesen und Erkanntem;
  „Mailverlauf“ heißt jetzt „Gesendete E-Mails“.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:03:11 +01:00
LarsandClaude Opus 5.5 6862dec201 v0.11 U6: Bring your own key für die KI-Auswertung (Anthropic, OpenRouter)
Deploy FeWo mit PipelineManager / deploy (push) Successful in 5m11s
- Jeder Mandant verbindet unter „System › KI-Anbindung“ seinen eigenen
  Zugang: Anbieter (Anthropic oder OpenRouter), API-Schlüssel, Modell für
  die erste Auswertung und für die Prüfung – keine Modellkennung im Code,
  kein zentraler Betreiberschlüssel (FEWO_AI_API_KEY entfällt).
- Gespeichert im bestehenden TenantService (ai_guest_mail): Schlüssel
  verschlüsselt, nie wieder angezeigt, nie in Meldungen; Anbieter/Modelle
  in settings, Prüfergebnis in check_status/check_message/checked_at.
- Feste Endpunkte je Anbieter (AiProvider), nicht konfigurierbar.
  OpenRouter mit response_format json_schema (strict) und
  provider.require_parameters.
- „Verbindung prüfen“ testet beide Modelle. Ein abgelehnter Zugang
  (401/402/403) schaltet die Auswertung für den Mandanten ab, meldet es im
  Postfach der Verwaltung; Nachrichten bleiben zur Prüfung im Posteingang.
- Zweistufige Extraktion und ihre Sicherheitsregeln unverändert.
- Zielarchitektur §3.8, Umsetzungsplan U6, Bericht, Drehbuch, Status.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 14:19:13 +01:00
LarsandClaude Opus 5.5 6f9aa46943 v0.11: Umsetzungsbericht, Abnahme-Drehbuch, Status; InboxTest wiederhergestellt
- 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 <noreply@anthropic.com>
2026-11-03 14:03:17 +01:00
LarsandClaude Opus 5.5 73c0a716b9 v0.11: durchgehender Integrationstest des MVP (Anfrage bis Buchung, Portalbuchung)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:55:35 +01:00
LarsandClaude Opus 5.5 4170e3bd29 v0.11 U6: risikobasierte KI-Extraktion von Gast- und Portalnachrichten
- Kleines Modell (claude-haiku-5-5) extrahiert Fakten mit Belegstelle und
  Konfidenz; programmatische Prüfung (Gültigkeit, Belegstelle im Original,
  Widerspruch zum gespeicherten Wert oder in der Nachricht, Plausibilität,
  Kritikalität nach Feld und Phase). Widerspruch oder fehlgeschlagene
  Prüfung → Prüfmodell (claude-opus-5-5, serverseitiger Fallback bei
  Ablehnung) unabhängig von der Konfidenz; solche Fakten nie automatisch.
- Nur geprüfte, bisher fehlende Angaben gehen an den Fakteneingang (Quelle
  „llm“); Zeitraum/Personen nur als Änderungswunsch (M06); Rest als
  Vorschlag im Posteingang („Vorschläge übernehmen“).
- Versionierte Prompts mit Platzhaltern, JSON-Schema mit eigener
  Validierung und einer Wiederholung; Ausfall/Ablehnung → sicherer
  Rückfall zur Vermieterin. HTTP-Client, kein SDK (laut Plan).
- Dienst „KI: Gästekommunikation“ verdrahtet, standardmäßig aus;
  Schlüssel je Mandant oder FEWO_AI_API_KEY; Verbrauch in service_usages.
- messages:extract alle fünf Minuten; ai:evaluate misst Fehlwerte und
  übersehene Angaben getrennt (M05).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:49:51 +01:00
LarsandClaude Opus 5.5 dff9e2344e v0.11 U5: Posteingang, deterministische Zuordnung, Klärungsansicht
- mailboxes (Modell für mehrere, eines aktiv): Übernahme des bisherigen
  Postfachs als „nur Portal-Mails“; Modus „alle Nachrichten“ für ein
  eigenes Postfach; Adresse als Antwortadresse der Rückfragen.
- inbound_messages: jede Nachricht zuerst gespeichert, einmal je
  Message-ID, mit Testbetriebs-Kennzeichen (M10). Portal-Mails laufen
  unverändert über den Portalpfad (CH-08).
- MessageMatcher (CH-13, ohne Scoring): Antwortbezug; Vorgangsnummer nur
  mit dem Gast als Absender; sonst Absender + Wohnung + beide Termine eines
  einzigen offenen Vorgangs. Ein offener Vorgang des Absenders allein
  genügt nicht (nur Hinweis). Alles andere → Klärung (M04).
- Ausgehende Mails speichern ihre Message-ID; Antwort stoppt Erinnerungen.
- Filament „Posteingang“: lesen, Vorgang zuordnen, als neue Anfrage
  anlegen, ignorieren, erledigt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:39:20 +01:00
LarsandClaude Opus 5.5 e4a3cb7f7b v0.11 U4: Rückfrage, Folgefrage, Erinnerung und Ergänzungslink
- data_requests: ein Beschaffungsvorgang je Vorgang mit Modus
  (automatisch / Freigabe / manuell), getrennten Zählern für Folgefragen
  und Erinnerungen ohne Rücksetzen, Antwortfrist ≠ Reservierungsfrist.
- RequestCaseData: fragt nach, was für das nächste Angebot, die
  Wunschbestätigung oder (bei verbindlichen Buchungen) administrativ fehlt;
  ohne E-Mail keine Rückfrage. Teilantwort → gezielte Folgefrage, Schweigen
  → Erinnerungen, an der Grenze Aufgabe für die Vermieterin. Nie ein Hold.
- Mail DataRequested mit Texten nach tatsächlichem Sperrstatus (M11);
  Dokumentart „Rückfrage“ – im Live-Betrieb ohne Freigabe nur nach Klick.
- Signierter, versionierter Ergänzungslink (/angebot/angaben): Lesen
  schreibt nicht, Absenden über den Fakteneingang, idempotent.
- Vorgang: „Rückfrage an den Gast senden“ / „Rückfrage beenden“;
  Eingangsbestätigung nennt die Klärungsreservierung korrekt.
- Zeitplan: cases:data-requests alle fünf Minuten.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:25:48 +01:00
LarsandClaude Opus 5.5 37f48defcc v0.11 U3: Klärungsreservierung für unvollständige Anfragen
- bookings.hold_purpose (offer wie bisher / clarification).
- RequestHold: vollständige Anfrage → Angebots-Hold unverändert;
  unvollständig, aber Wohnung, Zeitraum, verwendbare E-Mail und freier
  Zeitraum → nur Klärungsreservierung (15 min automatisch / 180 min
  Freigabe oder manuell, 0 = keine); sonst nichts (B1). Auch für
  Portalanfragen ohne Gastdaten.
- ExpireReservations beendet nur Angebots-Holds; ein abgelaufener
  Klärungsblock gibt nur den Kalender frei, der Vorgang bleibt offen.
- Vervollständigen erzeugt keinen Hold; erst SendOffer setzt den
  unveränderten Angebots-Hold. AutoOffer prüft danach nur die Verfügbarkeit.
- Booking::clarificationState() liefert den tatsächlichen Sperrstatus.
- Architekturtest: nur die bestehenden Reservierungsschritte schreiben Holds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:13:24 +01:00
LarsandClaude Opus 5.5 ccac78a6c9 v0.11 U2: Angebots-Gate, gemeinsamer Fakteneingang mit Herkunft
- CaseRequirements: Vor einem eigenen verbindlichen Angebot und vor der
  verbindlichen Bestätigung eines Buchungswunsches müssen Vor- und
  Nachname, E-Mail, vollständige Anschrift mit Land, Personenzahl und
  Zeitraum vorliegen – harter Blocker, auch von Hand (G2a, B3). Die
  Auskunft unter Vorbehalt bleibt ohne dieses Gate.
- ContributeCaseFacts (S5): jede Angabe mit Herkunft und Ergebnis in
  case_facts; fehlend → übernommen, gleich → bestätigt, abweichend vom
  Gast → Prüfaufgabe (Kartei bleibt), Vermieterin maßgeblich, Zeitraum und
  Personen → Änderungswunsch; idempotent; danach einmal CaseAutomation.
- ProvideGuestContact und Webformular nutzen den Fakteneingang.
- Land als ISO-Code mit „Deutschland“ als änderbarem Formularstandard;
  guests.country ohne stillen Standardwert (B4).
- Testdaten bestehender Tests um Anschriften ergänzt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:07:18 +01:00
LarsandClaude Opus 5.5 799869c6a4 v0.11 U1: Kanalmanager mit eigener Webseite und neuen Prozessparametern
- Eigene Webseite als Kanal eigener Art (channels.kind = website), nur zur
  Konfiguration: Webseiten-Anfragen bleiben direkt (A1) ohne Kanalbezug;
  der Eintrag nimmt an Sync, Export, Überwachung und Sperraufgaben nicht teil
  (active()/Property::channels() nur Portale, Feed nur für Portale).
- Neue Einstellungen im bestehenden ProcessSetting: Klärungsreservierung
  automatisch/Freigabe (15/180 min, 0 = keine), Rückfragemodus,
  Erinnerungen, Folgefragen, Erinnerungsabstand, Linkgültigkeit,
  Anschrift im Webformular verlangen (Standard: nein).
- „Kanäle“ in der einfachen Ansicht: Webseite und Portale an einer Stelle,
  Verweis auf „Ihre Standards“; „Wirksame Einstellungen“ mit Spalte
  „Eigene Webseite“ und Herkunft „Webseite“.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 12:52:50 +01:00
LarsandClaude Opus 5.5 bfccfe7eed v0.11: Soll-Ist-Analyse, technische Zielarchitektur und Umsetzungsplan
Planung zur Prozessarchitektur v0.11 (Communication Handler,
Datenbeschaffung, Klärungsreservierung, zentraler Kanalmanager) mit sechs
Umsetzungspaketen U1–U6. Betreiberentscheidungen B1–B4 vom 03.11.2026
eingearbeitet; Präzisierungen zur Zuordnung direkter Gast-Mails (CH-13)
und zur KI-Eskalation unabhängig von der Modellkonfidenz.

Keine Codeänderung.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 12:32:48 +01:00
Lars 9a9e5e157e Prozessarchitektur V0.11 2026-11-03 12:13:09 +01:00
LarsandClaude Opus 5.5 2d2ffffa33 Nächster Schritt sofort sichtbar, Saisonkopie ohne Preislücke
Deploy FeWo mit PipelineManager / deploy (push) Successful in 4m34s
- Vorgang: Die Kopfaktionen werden nach jeder Aktion neu aufgebaut, damit der
  große Schalter gleich den nächsten Schritt zeigt (Filament baut sie vor der
  Aktion auf).
- In Folgejahr kopieren: Reicht eine bestehende Saison (z. B. Neujahr über den
  Jahreswechsel) nur über Beginn oder Ende der Kopie, wird die Kopie dort
  gekürzt statt ganz übersprungen; sonst blieb z. B. Januar bis März ohne Preis.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:53:13 +01:00
LarsandCursor 150a64e100 Prüfbericht zum Eingang und zur Datenanreicherung sichern, mit dem Archiv der Prozessarchitektur v0.9.
Deploy FeWo mit PipelineManager / deploy (push) Successful in 4m40s
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-02 12:41:21 +01:00
LarsandClaude Opus 5.5 234e642e4d Pakete 7 und 9 abgeschlossen: Wirksamkeit, Browserbefunde, Gesamtabnahme
- Wirksame Einstellungen: Antwort auf Anfragen, Aufenthalt je Wohnung,
  Dokument und beide Abschlüsse je Vorgang
- Schritte vor dem Aufenthalt entfallen nach der Abreise; direkt bestaetigte
  Vorgaenge zeigen keine Auskunft; "Als Naechstes" ohne fremden Detailtext
- Automatische Wunschbestaetigung nur mit freigegebenen Vertragstexten
- Taeglicher Lauf bewertet auch bereits abgeschlossene Vorgaenge kaufmaennisch
- Dokumente: UMSETZUNGSERGEBNIS_P7_P9, END_TO_END_ABNAHME (T01-T25),
  KONFIGURATION_UND_WIRKSAMKEIT, GESAMTABNAHME_v0.10, STATUS; Screenshots

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:51:24 +01:00
LarsandClaude Opus 5.5 40d20cb7d1 Pakete 7 und 9: Auskunft und Buchungswunsch, Aufenthalt und Abschluss (Zwischenstand)
- Haltefrist 0: unverbindliche Auskunft mit signiertem Link "Buchung anfragen",
  erneute Prüfung unter Sperre, automatische oder manuelle Bestätigung, Absage
  bei vergebenem Zeitraum, Ablauf unbeantworteter Auskünfte
- Aufenthalt: Anreisedaten, Aufgaben je Wohnung, gebuchte Leistungen,
  Abweichungen und Folgeaufgaben als Aufgaben am Vorgang
- Abschluss getrennt: Aufenthalt abgeschlossen / kaufmännisch abgeschlossen,
  Nachläufer (Forderung, Auszahlung) bleiben sichtbar
- Zahlungsstatus nur aus Geld auf unserem Konto; Altbestand per Vorschau-Befehl
- Verlauf weist Testzustellungen als solche aus
- Abnahmetests T16-T25, T23 über isolierten SMTP-Empfänger

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 08:29:19 +01:00
214 changed files with 13631 additions and 458 deletions

No files matched your search

+1 -1
View File
@@ -41,7 +41,7 @@ public function handle(Booking|BlockedPeriod $occupation, ?int $guestId, array $
'tags' => ['nullable', 'array'],
'tags.*' => ['string', 'max:255'],
])->validate();
$guest = new Guest([...$data, 'last_name' => $data['last_name'] ?? '', 'email' => filled($data['email'] ?? null) ? mb_strtolower(trim($data['email'])) : null, 'country' => $data['country'] ?? 'DE']);
$guest = new Guest([...$data, 'last_name' => $data['last_name'] ?? '', 'email' => filled($data['email'] ?? null) ? mb_strtolower(trim($data['email'])) : null, 'country' => $data['country'] ?? null]);
$guest->forceFill(['tenant_id' => $record->tenant_id])->save();
}
$record->forceFill(['guest_id' => $guest->id])->save();
+27 -8
View File
@@ -12,6 +12,7 @@
use App\Exceptions\ReservationException;
use App\Models\Booking;
use App\Pricing\QuoteException;
use App\Process\CaseRequirements;
use App\Support\Content;
use App\Support\Settings;
@@ -19,6 +20,9 @@
* Automatic offer processing (property setting "Automatisch"): sends the offer without the landlord when every
* release rule is met, otherwise leaves the request untouched for manual processing and says why.
*
* A request without a hold (pre-reservation "no") gets the information "unter Vorbehalt" instead of the offer (package 7);
* its rules are the same except the reservation.
*
* Rules: pre-reservation active (the dates are really blocked), guest e-mail known, dates still free, contract
* texts released by the landlord (not the sample text; skipped while mails only go to the test recipient),
* the calendar clearance of {@see CalendarClearance} (fresh imports, instant-booking portals fetched our feed) and an
@@ -30,6 +34,7 @@ public function __construct(
private SendOffer $sendOffer,
private CalendarClearance $clearance,
private AvailabilityChecker $availability,
private SendInformation $sendInformation,
) {}
public function applies(Booking $booking): bool
@@ -44,15 +49,20 @@ public function blockers(Booking $booking): array
{
$property = $booking->property;
$reasons = [];
$information = ! $booking->process()->preReservation();
if (! $booking->process()->preReservation()) {
$reasons[] = 'Anfragen reservieren den Zeitraum nicht (Einstellung „Vorreservierung“); ohne Sperre im Kalender wird kein Angebot automatisch erteilt.';
if ($information && ($booking->status !== BookingStatus::Reserved || $booking->information_version > 0)) {
$reasons[] = 'Die Anfrage ist bereits beantwortet oder nicht mehr offen.';
}
if ($booking->status !== BookingStatus::Reserved || ! $booking->isHoldActive()) {
// A request after its clarification hold (v0.11) only needs free dates, which are checked below.
$clarified = $booking->hold_purpose === Booking::HOLD_CLARIFICATION;
if (! $information && ($booking->status !== BookingStatus::Reserved || (! $clarified && ! $booking->isHoldActive()))) {
$reasons[] = 'Die Anfrage ist nicht mehr vorgemerkt (Frist abgelaufen oder bereits bearbeitet).';
}
if (blank($booking->guest?->email)) {
$reasons[] = 'Die E-Mail-Adresse des Gastes fehlt.';
} elseif (! $information && ($missing = CaseRequirements::blocker($booking, CaseRequirements::OFFER)) !== null) {
$reasons[] = $missing;
}
if (! $this->availability->isAvailable($property, $booking->arrival, $booking->departure, ignore: $booking)) {
$reasons[] = 'Der Zeitraum ist inzwischen belegt.';
@@ -61,10 +71,11 @@ public function blockers(Booking $booking): array
$reasons[] = 'Mietbedingungen, Stornobedingungen oder Bankverbindung sind noch nicht vom Betreiber freigegeben (leer oder Mustertext).';
}
// Status, e-mail, dates and the missing reservation are checked above; the composition adds what concerns the document.
$reasons = [...$reasons, ...app(DocumentComposer::class)->compose($booking, DocumentKind::Offer)->toConfirm(except: [DocumentFinding::HOLD_ZERO])];
// Status, e-mail and dates are checked above; the composition adds what concerns the document.
$reasons = [...$reasons, ...app(DocumentComposer::class)->compose($booking, $information ? DocumentKind::Information : DocumentKind::Offer)->toConfirm(except: [DocumentFinding::HOLD_ZERO])];
return [...$reasons, ...$this->clearance->reasons($property, $booking->created_at)];
// An information reserves nothing and binds nobody: the calendar is checked again when the guest asks for the booking.
return $information ? $reasons : [...$reasons, ...$this->clearance->reasons($property, $booking->created_at)];
}
/**
@@ -86,7 +97,11 @@ public function handle(Booking $booking): array
}
try {
$this->sendOffer->handle($booking->fresh(), ['expected_version' => 0]);
if (! $booking->process()->preReservation()) {
$this->sendInformation->handle($booking->fresh(), ['expected_version' => 0, 'acknowledged' => true]);
} else {
$this->sendOffer->handle($booking->fresh(), ['expected_version' => 0]);
}
} catch (QuoteException|ReservationException $exception) {
// A mail failure keeps the saved offer (SendOffer reports it in the inbox); the landlord can resend the link.
return [$exception->getMessage()];
@@ -95,7 +110,11 @@ public function handle(Booking $booking): array
return [];
}
private function contractTextsReleased(): bool
/**
* Whether the landlord's own contract terms, cancellation terms and bank account are in place (always true while
* mails only go to the test recipient).
*/
public function contractTextsReleased(): bool
{
if (! Settings::isLive()) {
return true;
+8
View File
@@ -11,6 +11,7 @@
use App\Mail\CancellationRequested;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Process\CaseClosure;
use App\Process\CaseLog;
use App\Support\CancellationCost;
use App\Support\Money;
@@ -65,6 +66,11 @@ public function handle(Booking $booking, bool $notifyGuest = true, bool $costsTa
->whereIn('kind', [BookingTaskKind::CancellationRequest, BookingTaskKind::PortalCancellation, BookingTaskKind::PortalCancellationReported])
->where('status', BookingTaskStatus::Open)
->update(['status' => BookingTaskStatus::Done, 'completed_by' => $by, 'completed_at' => now()]);
// The stay will not take place: its preparation is no longer needed (package 9); issues and follow-ups stay.
BookingTask::query()->where('booking_id', $booking->id)
->whereIn('kind', [BookingTaskKind::ArrivalDetails, BookingTaskKind::Service, BookingTaskKind::DepositReminder, BookingTaskKind::BalanceRequest, BookingTaskKind::BalanceReminder])
->where('status', BookingTaskStatus::Open)
->update(['status' => BookingTaskStatus::Dismissed, 'note' => 'Storniert – entfällt.', 'completed_by' => $by, 'completed_at' => now()]);
$this->refundTask($booking);
@@ -79,6 +85,8 @@ public function handle(Booking $booking, bool $notifyGuest = true, bool $costsTa
});
$booking->loadMissing(['guest', 'property']);
// A cancellation without anything to settle is closed commercially at once; costs or a refund keep it open.
CaseClosure::refresh($booking->fresh());
return $this->notify($booking, $notifyGuest);
}
+133
View File
@@ -0,0 +1,133 @@
<?php
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\Responsibility;
use App\Exceptions\ReservationException;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Pricing\CaseMoney;
use App\Process\CaseClosure;
use App\Process\CaseLog;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
/**
* Package 9, P05 (gate B4 as decided by the operator): closes the stay after the departure – automatically once no task
* of the stay is open any more, or by the landlord, who marks the remaining stay tasks as done or handed over. Open
* money does not hold the stay up: it becomes a follow-up on the same case (claim against the guest, payout of the
* portal) and keeps the commercial closing open until it is clear.
*/
class CloseStay
{
/**
* Daily: closes every stay whose departure has passed and nothing of the stay is open any more.
*
* @return int the number of stays closed now
*/
public function due(): int
{
$closed = 0;
$stays = Booking::query()
->whereIn('status', [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid])
->whereDate('departure', '<', CarbonImmutable::today())
->with(['guest', 'property', 'payments', 'importChannel', 'originChannel'])
->get();
foreach ($stays as $booking) {
// After the departure the arrival details are of no use any more.
foreach (BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::ArrivalDetails)->where('status', BookingTaskStatus::Open)->get() as $task) {
$task->update(['status' => BookingTaskStatus::Dismissed, 'note' => 'Nach der Abreise nicht mehr nötig.', 'completed_by' => CaseLog::SYSTEM, 'completed_at' => now()]);
}
if (CaseClosure::stayBlockers($booking)->isNotEmpty()) {
continue;
}
CaseLog::context(fn () => $this->close($booking), actor: CaseLog::SYSTEM.' (automatisch)');
$closed++;
}
// Cases closed before package 9 (or whose money became clear without a payment) get their commercial closing too.
$unsettled = Booking::query()->whereIn('status', [BookingStatus::Completed, BookingStatus::Cancelled])->whereNull('settled_at')
->whereDate('departure', '>', CarbonImmutable::today()->subYear())->with(['payments', 'importChannel', 'originChannel'])->get();
foreach ($unsettled as $booking) {
CaseLog::context(fn () => CaseClosure::refresh($booking), actor: CaseLog::SYSTEM.' (automatisch)');
}
return $closed;
}
/**
* The landlord closes the stay; open tasks of the stay are marked as done or handed over with the note.
*
* @throws ReservationException
*/
public function byHand(Booking $booking, string $by, ?string $note = null): void
{
if (! in_array($booking->status, [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid], true)) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'abgeschlossen');
}
if ($booking->departure->isAfter(CarbonImmutable::today())) {
throw new ReservationException('Der Aufenthalt endet erst am '.$booking->departure->format('d.m.Y').'.');
}
CaseLog::context(function () use ($booking, $by, $note): void {
foreach (CaseClosure::stayBlockers($booking) as $task) {
$task->complete($by, filled($note) ? $note : 'Mit dem Abschluss des Aufenthalts erledigt bzw. übergeben.');
}
BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::ArrivalDetails)->where('status', BookingTaskStatus::Open)
->update(['status' => BookingTaskStatus::Dismissed, 'completed_by' => $by, 'completed_at' => now()]);
$this->close($booking);
}, actor: $by, reason: $note);
}
private function close(Booking $booking): void
{
DB::transaction(function () use ($booking): void {
$booking->lockForTransition();
if (! in_array($booking->status, [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid], true)) {
return;
}
$booking->update(['status' => BookingStatus::Completed, 'completed_at' => now()]);
$this->followUps($booking);
});
CaseClosure::refresh($booking->fresh());
}
/**
* Open money becomes a follow-up of the closed stay, so it stays visible and assigned.
*/
private function followUps(Booking $booking): void
{
$booking->unsetRelation('payments');
$money = CaseMoney::of($booking);
if ($money->collector() === Responsibility::Landlord && $money->openForUs() > 0) {
$chasing = BookingTask::query()->where('booking_id', $booking->id)->where('status', BookingTaskStatus::Open)->get()->contains(fn (BookingTask $task): bool => $task->kind->isPayment());
if (! $chasing) {
BookingTask::openOnce($booking, BookingTaskKind::OpenClaim, '', ['due_on' => today(), 'note' => 'Noch offen vom Gast: '.Money::format($money->openForUs()).'.']);
}
}
if ($money->collector() === Responsibility::Portal) {
$payout = $money->payout();
if ($payout['received'] === 0 || ($payout['outstanding'] ?? 0) > 0) {
$portal = $booking->processChannel()?->name ?? 'des Portals';
BookingTask::openOnce($booking, BookingTaskKind::PayoutCheck, '', [
'due_on' => $booking->departure->addDays(14),
'responsible' => $booking->processChannel()?->name,
'note' => match (true) {
$payout['values'] !== [] => 'Angekündigt: '.implode(' bzw. ', array_map(fn (int $value): string => Money::format($value), $payout['values'])).'; erhalten: '.Money::format($payout['received']).'.',
default => 'Auszahlung von '.$portal.' noch nicht erfasst.',
},
]);
}
}
}
}
+234
View File
@@ -0,0 +1,234 @@
<?php
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\FactSource;
use App\Events\CaseFactsContributed;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\CaseFact;
use App\Models\Guest;
use App\Process\CaseAutomation;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use App\Process\FactContribution;
use Illuminate\Support\Facades\DB;
/**
* The common fact intake of v0.11 (S5, CH-03, E-038). Every source – website form, the guest's link, an e-mail,
* a portal mail, the extraction, the landlord – hands its details for a case to this one place:
*
* - a missing value is taken over, an equal one confirmed;
* - a different contact or address value from the guest's side is never written over the stored one: it becomes a
* conflict for the landlord (the guest record may belong to other cases too);
* - the landlord's own entry is authoritative and replaces the value, the previous one stays in the evidence;
* - dates and the number of guests are stay details: a differing value (and in a binding case also a missing one from
* the guest's side) is only a change request for the landlord – nothing about the booking changes here;
* - invalid values are rejected.
*
* Every detail is recorded with source and outcome. The same contribution again is harmless (idempotent). Afterwards
* the existing process is asked once to carry on (S6); this intake decides nothing about offers or bookings.
*/
class ContributeCaseFacts
{
/** Stay details: never changed through the intake once known (P02/P03: change requests). */
public const STAY_FIELDS = ['booking.guests', 'booking.arrival', 'booking.departure'];
/**
* @param array<string, mixed> $facts field key ({@see CaseRequirements::FIELDS} or OPTIONAL_FIELDS) => value
* @param array{reference?: string, inbound_message_id?: int, evidence?: array<string, string>, confidence?: array<string, float>, actor?: string, advance?: bool} $options
*/
public function handle(Booking $booking, array $facts, FactSource $source, array $options = []): FactContribution
{
$known = [...CaseRequirements::FIELDS, ...CaseRequirements::OPTIONAL_FIELDS];
$facts = array_filter(array_map(fn (mixed $value): mixed => is_string($value) ? trim($value) : $value, array_intersect_key($facts, $known)), fn (mixed $value): bool => $value !== null && $value !== '');
if (isset($facts['guest.email'])) {
$facts['guest.email'] = mb_strtolower((string) $facts['guest.email']);
}
if ($facts === []) {
return new FactContribution;
}
$actor = $options['actor'] ?? ($source === FactSource::Landlord ? (auth()->user()?->name ?? 'Vermieter') : CaseLog::GUEST);
$reference = (string) ($options['reference'] ?? $options['inbound_message_id'] ?? '');
$contribution = DB::transaction(function () use ($booking, $facts, $source, $options, $actor, $reference): FactContribution {
$booking->lockForTransition();
$booking->load('guest');
$recorded = [];
$guestChanges = [];
$bookingChanges = [];
foreach ($facts as $field => $value) {
$value = is_scalar($value) ? (string) $value : json_encode($value);
$fingerprint = hash('sha256', implode('|', [$booking->id, $source->value, $reference, $field, mb_strtolower($value)]));
if (CaseFact::query()->withoutGlobalScopes()->where('booking_id', $booking->id)->where('fingerprint', $fingerprint)->exists()) {
continue;
}
$current = CaseRequirements::value($booking, $field);
$outcome = $this->outcome($booking, $field, $value, $current, $source);
if ($outcome === CaseFact::APPLIED) {
[$scope, $attribute] = explode('.', $field, 2);
if ($scope === 'guest') {
$guestChanges[$attribute] = $value;
} else {
$bookingChanges[$attribute] = $field === 'booking.guests' ? (int) $value : $value;
}
}
$recorded[] = new CaseFact([
'booking_id' => $booking->id,
'field' => $field,
'value' => $value,
'previous_value' => filled($current) ? (string) $current : null,
'source' => $source,
'inbound_message_id' => $options['inbound_message_id'] ?? null,
'evidence' => $options['evidence'][$field] ?? null,
'confidence' => $options['confidence'][$field] ?? null,
'outcome' => $outcome,
'fingerprint' => $fingerprint,
'actor' => $actor,
'created_at' => now(),
]);
}
$this->applyGuest($booking, $guestChanges, $recorded, $source);
if ($bookingChanges !== []) {
$booking->update($bookingChanges);
}
foreach ($recorded as $fact) {
$fact->tenant_id = $booking->tenant_id;
$fact->save();
}
$contribution = new FactContribution($recorded);
if (! $contribution->isEmpty()) {
$this->openTasks($booking, $contribution, $source);
CaseLog::record($booking, 'facts', 'Angaben von '.$source->getLabel().': '.$contribution->summary(), data: ['fields' => array_map(fn (CaseFact $fact): array => ['field' => $fact->field, 'outcome' => $fact->outcome], $recorded)], actor: $actor);
}
return $contribution;
});
if (! $contribution->isEmpty()) {
$booking->refresh()->load('guest');
event(new CaseFactsContributed($booking, $contribution, $source));
if ($contribution->anyApplied() && ($options['advance'] ?? true)) {
app(CaseAutomation::class)->advance($booking);
}
}
return $contribution;
}
/**
* Phase of the case for the rules (CH §1.4): binding (P3) or not.
*/
public static function isBinding(Booking $booking): bool
{
return in_array($booking->status, BookingStatus::occupying(), true);
}
private function outcome(Booking $booking, string $field, string $value, mixed $current, FactSource $source): string
{
if (! CaseRequirements::isValid($field, $value)) {
return CaseFact::REJECTED;
}
$known = CaseRequirements::isValid($field, $current);
if ($known && $this->same($field, $value, $current)) {
return CaseFact::CONFIRMED;
}
if (in_array($field, self::STAY_FIELDS, true)) {
// A stay detail never changes through the intake. Only an unknown number of guests may be completed – by the
// landlord or the portal's own message, or on a request that binds nobody yet.
$completes = ! $known && ($source->isAuthoritative() || $source === FactSource::PortalMail || ! self::isBinding($booking));
return $completes ? CaseFact::APPLIED : CaseFact::CHANGE_REQUEST;
}
if (! $known || $source->isAuthoritative()) {
return CaseFact::APPLIED;
}
return CaseFact::CONFLICT;
}
private function same(string $field, string $value, mixed $current): bool
{
if ($field === 'booking.guests') {
return (int) $value === (int) $current;
}
return mb_strtolower(preg_replace('/\s+/', ' ', $value)) === mb_strtolower(preg_replace('/\s+/', ' ', trim((string) $current)));
}
/**
* Writes the taken-over guest details. A case without a guest gets a new guest record once a name is known; a
* known e-mail address never joins another person's record silently (the landlord assigns it).
*
* @param array<string, string> $changes
* @param list<CaseFact> $recorded
*/
private function applyGuest(Booking $booking, array $changes, array $recorded, FactSource $source): void
{
if ($changes === []) {
return;
}
if ($booking->guest !== null) {
$booking->guest->update($changes);
return;
}
$email = $changes['email'] ?? '';
// The landlord knows whom he enters; any other source must not attach the case to somebody else's record.
$taken = ! $source->isAuthoritative() && $email !== '' && Guest::query()->where('email', $email)->exists();
if (blank($changes['first_name'] ?? null) || blank($changes['last_name'] ?? null) || $taken) {
foreach ($recorded as $fact) {
if ($fact->outcome === CaseFact::APPLIED && str_starts_with($fact->field, 'guest.')) {
$fact->outcome = CaseFact::CONFLICT;
}
}
return;
}
$guest = Guest::query()->create([...$changes, 'email' => $email, 'tenant_id' => $booking->tenant_id]);
$booking->update(['guest_id' => $guest->id]);
$booking->setRelation('guest', $guest);
}
private function openTasks(Booking $booking, FactContribution $contribution, FactSource $source): void
{
if ($source->isAuthoritative()) {
// The landlord's entry settles what was put to him for these details.
BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::FactConflict)->where('status', BookingTaskStatus::Open)
->whereIn('subject', array_map(fn (CaseFact $fact): string => $fact->field, $contribution->facts))
->get()->each(fn (BookingTask $task): bool => $task->forceFill(['status' => BookingTaskStatus::Done, 'completed_at' => now(), 'completed_by' => auth()->user()?->name, 'note' => trim($task->note.' · von Ihnen entschieden')])->save());
}
foreach ($contribution->facts as $fact) {
if ($fact->outcome === CaseFact::CONFLICT) {
BookingTask::openOnce($booking, BookingTaskKind::FactConflict, $fact->field, [
'due_on' => today(),
'note' => CaseRequirements::label($fact->field).' laut '.$source->getLabel().': „'.$fact->value.'“'.($fact->previous_value ? ' (bisher „'.$fact->previous_value.'“)' : ' (noch nicht eingetragen – Zuordnung prüfen)'),
]);
}
if ($fact->outcome === CaseFact::CHANGE_REQUEST) {
BookingTask::openOnce($booking, BookingTaskKind::ChangeRequest, $fact->field.':'.substr($fact->fingerprint, 0, 12), [
'due_on' => today(),
'note' => 'Gewünscht laut '.$source->getLabel().': '.CaseRequirements::label($fact->field).' „'.$fact->value.'“'.($fact->previous_value ? ' (gebucht: „'.$fact->previous_value.'“)' : '').'. Nichts wurde geändert – bitte über „Buchung ändern“ bzw. ein neues Angebot entscheiden.',
]);
}
}
}
}
+34 -3
View File
@@ -14,12 +14,13 @@ class CopySeasonsToNextYear
{
/**
* @param int|null $alignToWeekday ISO weekday (1 = Monday … 7 = Sunday) or null for the same calendar dates
* @return array{created: int, skipped: int}
* @return array{created: int, skipped: int, trimmed: int}
*/
public function handle(Property $property, int $year, ?int $alignToWeekday = null): array
{
$created = 0;
$skipped = 0;
$trimmed = 0;
$seasons = $property->seasons()->whereYear('starts_on', $year)->orderBy('starts_on')->get();
@@ -38,7 +39,8 @@ public function handle(Property $property, int $year, ?int $alignToWeekday = nul
continue;
}
if ($property->seasons()->overlapping($startsOn, $endsOn)->exists()) {
[$startsOn, $endsOn, $wasTrimmed] = $this->fitBetweenExisting($property, $startsOn, $endsOn);
if ($startsOn === null || $endsOn === null) {
$skipped++;
continue;
@@ -50,9 +52,38 @@ public function handle(Property $property, int $year, ?int $alignToWeekday = nul
'ends_on' => $endsOn,
]);
$created++;
$trimmed += $wasTrimmed ? 1 : 0;
}
return ['created' => $created, 'skipped' => $skipped];
return ['created' => $created, 'skipped' => $skipped, 'trimmed' => $trimmed];
}
/**
* Existing seasons win. One that only reaches over the start or the end of the copy shortens the copy there (e.g.
* a season over the turn of the year that ends a day after the moved start), so no nights stay without a price;
* the copy is left out only when an existing season lies within it or covers it completely.
*
* @return array{0: ?CarbonImmutable, 1: ?CarbonImmutable, 2: bool}
*/
private function fitBetweenExisting(Property $property, CarbonImmutable $startsOn, CarbonImmutable $endsOn): array
{
$originalStart = $startsOn;
$originalEnd = $endsOn;
foreach ($property->seasons()->overlapping($startsOn, $endsOn)->get() as $existing) {
if ($existing->starts_on->lessThanOrEqualTo($startsOn) && $existing->ends_on->greaterThan($startsOn)) {
$startsOn = $existing->ends_on;
}
if ($existing->ends_on->greaterThanOrEqualTo($endsOn) && $existing->starts_on->lessThan($endsOn)) {
$endsOn = $existing->starts_on;
}
}
if ($endsOn->lessThanOrEqualTo($startsOn) || $property->seasons()->overlapping($startsOn, $endsOn)->exists()) {
return [null, null, false];
}
return [$startsOn, $endsOn, ! $startsOn->equalTo($originalStart) || ! $endsOn->equalTo($originalEnd)];
}
/**
+32 -3
View File
@@ -4,6 +4,7 @@
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
use App\Enums\FactSource;
use App\Enums\IntakeKind;
use App\Exceptions\ReservationException;
use App\Mail\NewReservation;
@@ -16,6 +17,7 @@
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\ProcessSettings;
use App\Process\RequestHold;
use App\Support\Settings;
use App\Tenancy\TenantContext;
use App\Tenancy\TenantContextMissing;
@@ -77,9 +79,15 @@ private function create(Property $property, StayRequest $stay, array $guestData,
$quote = $this->calculator->calculate($property, $stay);
[$guest, $differences] = $this->guestFor($guestData);
$profile = app(ProcessSettings::class)->resolve($property, $originChannel, IntakeKind::Inquiry);
$profile = $originChannel === null && $source === 'website'
? app(ProcessSettings::class)->forWebsite($property)
: app(ProcessSettings::class)->resolve($property, $originChannel, IntakeKind::Inquiry);
$draft = new Booking(['property_id' => $property->id, 'arrival' => $stay->arrival->toDateString(), 'departure' => $stay->departure->toDateString(), 'guests' => $stay->guests]);
$draft->setRelation('guest', $guest);
$hold = RequestHold::for($draft, $profile);
return $property->bookings()->create([
...$hold,
'guest_id' => $guest->id,
'status' => BookingStatus::Reserved,
'source' => $source,
@@ -95,12 +103,21 @@ private function create(Property $property, StayRequest $stay, array $guestData,
'total' => $quote->total(),
'deposit' => $quote->deposit(),
'balance_due_on' => $quote->balanceDueOn->toDateString(),
'hold_expires_at' => $profile->preReservation() ? now()->addHours($profile->holdHours()) : null,
'message' => $message,
'internal_notes' => $differences !== [] ? "Abweichende Angaben in dieser Anfrage (Gästekartei nicht geändert):\n".implode("\n", $differences) : null,
]);
});
if ($source === 'website') {
// Evidence of what the guest typed (v0.11, S5): completed fields are confirmed, differing ones go to the
// landlord as a conflict instead of only a note. The guest record itself was already handled above.
$facts = collect(Arr::only($guestData, ['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city', 'country']))
->filter(fn (?string $value): bool => filled($value))
->mapWithKeys(fn (string $value, string $field): array => ['guest.'.$field => $value])->all();
app(ContributeCaseFacts::class)->handle($booking, $facts, FactSource::WebsiteForm, ['advance' => false, 'reference' => 'request']);
$booking->refresh();
}
if ($sendMails) {
$this->sendMails($booking);
}
@@ -174,8 +191,20 @@ private function sendMails(Booking $booking): void
$offerSent = false;
}
// v0.11: details for the offer are missing – the data request asks for them (and then replaces the receipt).
$asked = false;
if (! $offerSent) {
try {
$request = app(RequestCaseData::class)->forNextStep($booking);
$asked = $request?->last_sent_at !== null;
$booking->refresh();
} catch (Throwable $exception) {
Log::warning('Rückfrage fehlgeschlagen', ['booking' => $booking->id, 'exception' => $exception::class]);
}
}
try {
if (! $offerSent && filled($booking->guest?->email)) {
if (! $offerSent && ! $asked && filled($booking->guest?->email)) {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new ReservationReceived($booking));
}
Mail::to(Settings::notificationRecipients())->send(new NewReservation($booking, $offerSent, $blockers));
+114
View File
@@ -0,0 +1,114 @@
<?php
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Exceptions\ReservationException;
use App\Mail\BookingWishAnswered;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Pricing\StayRequest;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Throwable;
/**
* The landlord decides on a booking wish (package 7, "Buchungswunsch bestätigen?"): confirm it – availability is checked
* once more under the lock, so two wishes for the same dates can never both become bookings – or decline it with a
* friendly answer. The price is the one the guest was told; a lower price of today may be granted, a higher one needs a
* new information the guest asks for again.
*/
class DecideBookingWish
{
public function __construct(private ConfirmBooking $confirm, private SendOffer $offer) {}
/**
* @return bool whether the guest has the confirmation
*
* @throws ReservationException
*/
public function confirm(Booking $booking, bool $useTodaysPrice = false, bool $notifyGuest = true): bool
{
if ($notifyGuest && blank($booking->guest?->email)) {
throw new ReservationException('Vor dem E-Mail-Versand bitte die E-Mail-Adresse des zugeordneten Gastes ergänzen.');
}
DB::transaction(function () use ($booking, $useTodaysPrice): void {
$booking->lockForTransition();
if ($booking->status !== BookingStatus::Reserved || $booking->wish_at === null) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'als Buchungswunsch bestätigt');
}
// G2a also before the binding confirmation of a wish (v0.11, B3), by hand as well.
if (($missing = CaseRequirements::blocker($booking->load('guest'), CaseRequirements::WISH_CONFIRMATION)) !== null) {
throw new ReservationException($missing);
}
if ($useTodaysPrice) {
$quote = $this->offer->quoteFor($booking, new StayRequest($booking->arrival, $booking->departure, $booking->guests, $booking->extras ?? [], $booking->promo_code), (int) $booking->price_adjustment, (string) ($booking->price_adjustment_label ?: 'Zuschlag'));
if ($quote->total() > (int) $booking->total) {
throw new ReservationException('Der heutige Preis ist höher als der Preis der Auskunft. Ohne Zustimmung des Gastes geht das nicht – bitte eine neue Auskunft senden.');
}
$booking->update(['quote' => $quote->toArray(), 'total' => $quote->total(), 'deposit' => $quote->deposit(), 'balance_due_on' => $quote->balanceDueOn->toDateString()]);
}
$this->confirm->bind($booking);
$booking->update([
'accepted_at' => $booking->wish_at,
'acceptance' => [
'via' => 'booking_wish',
'information_version' => $booking->wish['information_version'] ?? $booking->information_version,
'wish_at' => $booking->wish_at?->toIso8601String(),
'total' => $booking->total,
'quote_sha256' => SendInformation::quoteHash($booking),
'terms_sha256' => $booking->wish['terms_sha256'] ?? null,
'confirmed_by' => CaseLog::actor(),
'confirmed_at' => now()->toIso8601String(),
],
]);
$this->closeTasks($booking, 'Bestätigt.');
});
$booking->refresh();
CaseLog::record($booking, 'wish', 'Buchungswunsch bestätigt – Buchung verbindlich');
return $this->confirm->deliver($booking, $notifyGuest);
}
/**
* @throws ReservationException
*/
public function decline(Booking $booking, ?string $reason = null, bool $notifyGuest = true): void
{
DB::transaction(function () use ($booking): void {
$booking->lockForTransition();
if ($booking->status !== BookingStatus::Reserved) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'abgesagt');
}
$booking->update(['status' => BookingStatus::Declined, 'declined_by' => 'us', 'hold_expires_at' => null]);
$this->closeTasks($booking, 'Abgesagt.');
});
CaseLog::record($booking, 'wish', 'Buchungswunsch abgesagt', reason: $reason);
if ($notifyGuest && filled($booking->guest?->email)) {
try {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new BookingWishAnswered($booking->fresh(), 'declined'));
} catch (Throwable $exception) {
Log::warning('Absage zum Buchungswunsch nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
}
}
}
private function closeTasks(Booking $booking, string $note): void
{
foreach (BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::BookingWish)->where('status', BookingTaskStatus::Open)->get() as $task) {
$task->complete(CaseLog::actor(), $note);
}
}
}
+8 -2
View File
@@ -9,7 +9,8 @@
use Illuminate\Support\Facades\Mail;
/**
* Marks reservations whose hold time is over as expired and tells the landlord.
* Marks reservations whose hold time is over – and information without a hold whose link expired unanswered – as
* expired and tells the landlord.
* The calendar already treats them as free once the hold time is over; this only updates the status.
*/
class ExpireReservations
@@ -18,7 +19,12 @@ public function handle(): int
{
$expired = Booking::query()
->whereIn('status', BookingStatus::holding())
->where('hold_expires_at', '<=', now())
->where(fn ($query) => $query
// A lapsed clarification hold (v0.11) only frees the calendar; the request stays open for its details.
->where(fn ($offer) => $offer->where('hold_expires_at', '<=', now())->where('hold_purpose', Booking::HOLD_OFFER))
// An information without a hold (package 7) ends when its link expires and the guest did not ask for the booking.
->orWhere(fn ($information) => $information->where('status', BookingStatus::Reserved)->whereNull('hold_expires_at')
->where('information_valid_until', '<=', now())->whereNull('wish_at')))
->with(['guest', 'property'])
->get();
+188
View File
@@ -0,0 +1,188 @@
<?php
namespace App\Actions;
use App\Communication\Extraction\AccessRejected;
use App\Communication\Extraction\AiAccess;
use App\Communication\Extraction\ExtractionFailed;
use App\Communication\Extraction\MessageExtractor;
use App\Communication\Extraction\RiskAssessment;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\FactSource;
use App\Enums\InboxMessageKind;
use App\Enums\TenantServiceKey;
use App\Filament\Pages\AiConnection;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\InboundMessage;
use App\Models\ServiceUsage;
use App\Process\CaseLog;
use App\Support\Inbox;
use App\Support\Settings;
/**
* The risk-based two-stage extraction of v0.11 (CH-14, E-035): the small model extracts facts with evidence and
* confidence, programmatic rules check phase, stored values, contradictions and plausibility, and – when the risk is
* high, something contradicts or a check fails – the review model looks at the original and the first extraction.
* Only facts that pass every check go to the common fact intake (which applies its own rules); everything else is
* proposed to the landlord in the inbox. Wishes to change the stay only become change requests. The extraction
* decides nothing binding; without the service, a key or a usable answer the message simply waits for the landlord.
*/
class ExtractMessageFacts
{
public function __construct(private MessageExtractor $extractor, private RiskAssessment $risk, private ContributeCaseFacts $facts) {}
/**
* @return string the extraction status: done, failed or disabled
*/
public function handle(InboundMessage $message): string
{
$booking = $message->booking()->with(['guest', 'property'])->first();
if ($booking === null || $message->extraction_status !== null) {
return (string) $message->extraction_status;
}
// Bring your own key: only the landlord's own, complete and not rejected access is used.
$access = AiAccess::for(Settings::tenant());
if ($access === null) {
$message->update(['extraction_status' => 'disabled']);
return 'disabled';
}
$record = ['prompt_version' => MessageExtractor::promptVersion()];
try {
$first = $this->extractor->extract($access, $message, $booking);
$this->meter();
$record['first'] = $first;
$data = $first['data'];
$checked = $this->risk->facts($booking, (string) $message->body, $data);
if ($this->risk->needsReview($booking, $checked, $data)) {
$review = $this->extractor->review($access, $message, $booking, $data);
$this->meter();
$record['review'] = $review;
$data = $review['data'];
$checked = $this->markDisagreements($this->risk->facts($booking, (string) $message->body, $data), $first['data']);
}
} catch (AccessRejected $exception) {
// The access is no longer valid: off for this landlord until he saves or checks it again (no retry loop).
AiAccess::markInvalid(Settings::tenant(), $exception->getMessage());
app(Inbox::class)->post(InboxMessageKind::AiAccessRejected, 'ai-access', 'KI-Anbindung abgelehnt', $exception->getMessage().' Die automatische Auswertung ist ausgeschaltet, bis Sie den Zugang unter System › KI-Anbindung prüfen. Nachrichten liegen im Posteingang.', actionUrl: AiConnection::getUrl());
$message->update(['extraction_status' => 'failed', 'extraction' => [...$record, 'error' => $exception->getMessage()]]);
return 'failed';
} catch (ExtractionFailed $exception) {
$message->update(['extraction_status' => 'failed', 'extraction' => [...$record, 'error' => $exception->getMessage()]]);
CaseLog::record($booking, 'mail_in', 'Automatische Auswertung nicht möglich – bitte die Nachricht selbst lesen', actor: CaseLog::SYSTEM);
return 'failed';
}
$automatic = array_values(array_filter($checked, fn (array $fact): bool => $this->risk->mayTakeOver($booking, $fact)));
$proposed = array_values(array_filter($checked, fn (array $fact): bool => ! in_array($fact, $automatic, true)));
$source = $message->status === InboundMessage::PORTAL ? FactSource::PortalMail : FactSource::Extraction;
if ($automatic !== []) {
$this->facts->handle($booking, collect($automatic)->mapWithKeys(fn (array $fact): array => [$fact['field'] => $fact['value']])->all(), $source, [
'inbound_message_id' => $message->id,
'reference' => 'message:'.$message->id,
'evidence' => collect($automatic)->mapWithKeys(fn (array $fact): array => [$fact['field'] => $fact['evidence']])->all(),
'confidence' => collect($automatic)->mapWithKeys(fn (array $fact): array => [$fact['field'] => $fact['confidence']])->all(),
'actor' => 'Auswertung der E-Mail (KI, geprüft nach Regeln)',
]);
}
$changes = $this->changeRequests($booking, $message, $data['change_requests']);
$message->update([
'extraction_status' => 'done',
'extraction' => [...$record, 'intent' => $data['intent'], 'uncertainties' => $data['uncertainties'], 'applied' => $automatic, 'proposed' => $proposed, 'change_requests' => $changes],
]);
$this->finish($message, $automatic, $proposed, $changes, $data['intent']);
return 'done';
}
/**
* Facts the two models disagree on are proposed, never taken over.
*
* @param list<array<string, mixed>> $checked
* @param array{facts: list<array{field: string, value: string}>} $first
* @return list<array<string, mixed>>
*/
private function markDisagreements(array $checked, array $first): array
{
$firstValues = collect($first['facts'])->mapWithKeys(fn (array $fact): array => [$fact['field'] => mb_strtolower(trim($fact['value']))])->all();
return array_map(function (array $fact) use ($firstValues): array {
if (isset($firstValues[$fact['field']]) && $firstValues[$fact['field']] !== mb_strtolower($fact['value'])) {
$fact['problems'][] = 'die beiden Modelle lesen den Wert unterschiedlich';
}
return $fact;
}, $checked);
}
/**
* Wishes to change the stay become change requests through the fact intake (dates, guests) or a task; nothing about
* the booking changes (E-038).
*
* @param list<array{field: string, value: string, evidence: string}> $requests
* @return list<array{field: string, value: string, evidence: string}>
*/
private function changeRequests(Booking $booking, InboundMessage $message, array $requests): array
{
$kept = array_values(array_filter($requests, fn (array $request): bool => $this->risk->evidenceFound((string) $message->body, $request['evidence'])));
$stay = array_filter($kept, fn (array $request): bool => in_array($request['field'], ContributeCaseFacts::STAY_FIELDS, true));
if ($stay !== []) {
$this->facts->handle($booking, collect($stay)->mapWithKeys(fn (array $request): array => [$request['field'] => $request['value']])->all(), FactSource::Extraction, [
'inbound_message_id' => $message->id, 'reference' => 'message-change:'.$message->id, 'advance' => false,
'evidence' => collect($stay)->mapWithKeys(fn (array $request): array => [$request['field'] => $request['evidence']])->all(),
]);
}
foreach (array_filter($kept, fn (array $request): bool => ! in_array($request['field'], ContributeCaseFacts::STAY_FIELDS, true)) as $request) {
BookingTask::openOnce($booking, BookingTaskKind::ChangeRequest, 'message:'.$message->id.':'.$request['field'], [
'due_on' => today(),
'note' => 'Wunsch laut E-Mail ('.$request['field'].'): „'.mb_substr($request['evidence'], 0, 200).'“. Nichts wurde geändert.',
]);
}
return $kept;
}
/**
* @param list<array<string, mixed>> $automatic
* @param list<array<string, mixed>> $proposed
* @param list<array<string, mixed>> $changes
*/
private function finish(InboundMessage $message, array $automatic, array $proposed, array $changes, string $intent): void
{
$booking = $message->booking;
$task = BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::InboundReview)->where('subject', 'm'.$message->id)->where('status', BookingTaskStatus::Open)->first();
$parts = array_filter([
$automatic !== [] ? count($automatic).' Angabe(n) übernommen' : null,
$proposed !== [] ? count($proposed).' Vorschlag/Vorschläge zu prüfen' : null,
$changes !== [] ? 'Änderungswunsch erkannt' : null,
]);
CaseLog::record($booking, 'mail_in', 'E-Mail ausgewertet: '.($parts === [] ? 'keine Angaben erkannt' : implode(', ', $parts)), actor: CaseLog::SYSTEM);
// Nothing left to look at: a pure answer whose details were all taken over.
if ($proposed === [] && $changes === [] && $automatic !== [] && $intent === 'answer') {
$task?->forceFill(['status' => BookingTaskStatus::Done, 'completed_at' => now(), 'completed_by' => CaseLog::SYSTEM, 'note' => trim($task->note.' · automatisch ausgewertet')])->save();
$message->update(['status' => $message->status === InboundMessage::PORTAL ? InboundMessage::PORTAL : InboundMessage::PROCESSED, 'processed_at' => now()]);
return;
}
$task?->forceFill(['note' => '„'.mb_substr((string) $message->subject, 0, 120).'“ – '.(implode(', ', $parts) ?: 'keine Angaben erkannt').'. Im Posteingang ansehen.'])->save();
}
private function meter(): void
{
if (($tenant = Settings::tenant()) !== null) {
ServiceUsage::query()->create(['tenant_id' => $tenant->id, 'service' => TenantServiceKey::AiGuestMail->value, 'quantity' => 1, 'used_at' => now()]);
}
}
}
+151
View File
@@ -0,0 +1,151 @@
<?php
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\InternalKind;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\Extra;
use App\Process\CaseLog;
use Carbon\CarbonImmutable;
/**
* Package 9, P04: prepares the stays of the coming two weeks – once per case and task, however often it runs.
*
* - **Arrival details:** a few days before the arrival information is due, a task asks for what is missing (a way to
* reach the guest; the arrival time where the property asks for it). It closes itself once the data is there. For a
* portal booking the contact may have to be fetched from the portal.
* - **Stay tasks of the property:** cleaning, linen, key handover … as configured on the property, with their due date.
* - **Booked services:** every extra of our own price (or of a private stay) becomes a task to provide it.
*
* Nothing is sent to guests here; the arrival information keeps going out by itself where we are responsible.
*/
class PrepareStays
{
/** How far ahead stays are prepared. */
public const LEAD_DAYS = 14;
/** Days before the arrival information that the arrival details are checked. */
private const DETAILS_BEFORE_INFO = 2;
/**
* @return array{arrival_details: int, stay_tasks: int}
*/
public function handle(): array
{
$today = CarbonImmutable::today();
$created = ['arrival_details' => 0, 'stay_tasks' => 0];
$stays = Booking::query()
->whereIn('status', [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid])
->whereDate('arrival', '<=', $today->addDays(self::LEAD_DAYS))
->whereDate('departure', '>=', $today)
->with(['guest', 'property', 'importChannel', 'originChannel'])
->get();
foreach ($stays as $booking) {
$created['arrival_details'] += $this->arrivalDetails($booking, $today) ? 1 : 0;
$created['stay_tasks'] += $this->stayTasks($booking);
}
return $created;
}
/**
* What is still missing for the arrival, in plain words (empty: nothing).
*
* @return list<string>
*/
public static function missingArrivalDetails(Booking $booking): array
{
if ($booking->isInternal()) {
return [];
}
return array_values(array_filter([
$booking->guest === null ? 'Name und Kontakt des Gastes' : null,
$booking->guest !== null && blank($booking->guest->email) && blank($booking->guest->phone) ? 'eine E-Mail-Adresse oder Telefonnummer des Gastes' : null,
$booking->property?->asks_arrival_time && blank($booking->arrival_time) ? 'die Anreisezeit' : null,
]));
}
/**
* Opens (or closes) the task for missing arrival details.
*/
private function arrivalDetails(Booking $booking, CarbonImmutable $today): bool
{
$missing = self::missingArrivalDetails($booking);
$open = BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::ArrivalDetails)->where('status', BookingTaskStatus::Open)->first();
if ($missing === []) {
$open?->complete(CaseLog::SYSTEM, 'Die Angaben liegen jetzt vor.');
return false;
}
$checkFrom = $booking->arrival->subDays($booking->process()->arrivalInfoDaysBefore() + self::DETAILS_BEFORE_INFO);
if ($today->lessThan($checkFrom)) {
return false;
}
$portal = $booking->caseType()->isExternallyBinding() ? ' (ggf. im Portal '.($booking->processChannel()?->name ?? '').' nachsehen)' : '';
$task = BookingTask::openOnce($booking, BookingTaskKind::ArrivalDetails, '', [
'due_on' => $booking->arrival->subDays($booking->process()->arrivalInfoDaysBefore()),
'note' => 'Es fehlt: '.implode(', ', $missing).$portal.'.',
]);
return $task->wasRecentlyCreated;
}
/**
* Opens the configured stay tasks and the tasks for booked services; returns how many were opened now.
*/
private function stayTasks(Booking $booking): int
{
$kind = match (true) {
! $booking->isInternal() => 'rental',
$booking->internal_kind === InternalKind::PrivateStay => 'private',
$booking->internal_kind === InternalKind::OwnUse => 'own',
default => 'block',
};
$opened = 0;
foreach ($booking->property?->stayTaskDefinitions() ?? [] as $definition) {
if (! in_array($kind, $definition['applies_to'], true)) {
continue;
}
$due = match ($definition['when']) {
'after_departure' => $booking->departure,
'on_arrival' => $booking->arrival,
default => $booking->arrival->subDays($definition['days']),
};
$task = BookingTask::openOnce($booking, BookingTaskKind::Service, $definition['key'], [
'title' => $definition['title'],
'responsible' => $definition['responsible'],
'due_on' => $due,
]);
// Dates of the stay may have changed since the task was opened.
if (! $task->wasRecentlyCreated && $task->status === BookingTaskStatus::Open && ! $task->due_on?->equalTo($due)) {
$task->update(['due_on' => $due]);
}
$opened += $task->wasRecentlyCreated ? 1 : 0;
}
// Booked services of our own price (a portal's extras are not known item by item).
if (($booking->quote['source'] ?? null) !== 'portal') {
$extras = array_filter((array) ($booking->extras ?? []), fn ($quantity): bool => (int) $quantity > 0);
foreach (Extra::query()->whereIn('id', array_keys($extras))->get() as $extra) {
$task = BookingTask::openOnce($booking, BookingTaskKind::Service, 'extra:'.$extra->id, [
'title' => 'Bereitstellen: '.((int) $extras[$extra->id] > 1 ? $extras[$extra->id].' × ' : '').$extra->name,
'due_on' => $booking->arrival->subDay(),
]);
$opened += $task->wasRecentlyCreated ? 1 : 0;
}
}
return $opened;
}
}
+7 -8
View File
@@ -3,6 +3,7 @@
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\FactSource;
use App\Enums\IntakeKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
@@ -41,15 +42,13 @@ public function handle(Booking $booking, array $contact, string $process = self:
throw new ReservationException('Für den automatischen Ablauf wird die E-Mail-Adresse des Gastes benötigt.');
}
if ($booking->guest === null) {
if (blank($contact['first_name'] ?? null) || blank($contact['last_name'] ?? null)) {
throw new ReservationException('Bitte Vor- und Nachnamen des Gastes angeben.');
}
$guest = Guest::query()->create([...array_filter($contact, fn ($value) => $value !== null), 'email' => $contact['email'] ?? '']);
$booking->update(['guest_id' => $guest->id]);
} else {
$booking->guest->update(array_filter($contact, fn ($value) => $value !== null));
if ($booking->guest === null && (blank($contact['first_name'] ?? null) || blank($contact['last_name'] ?? null))) {
throw new ReservationException('Bitte Vor- und Nachnamen des Gastes angeben.');
}
// The landlord's entry goes through the common fact intake (v0.11, S5): taken over with its source, the previous
// value kept as evidence. Carrying on stays with the choice below.
app(ContributeCaseFacts::class)->handle($booking, collect($contact)->mapWithKeys(fn (?string $value, string $field): array => ['guest.'.$field => $value])->all(), FactSource::Landlord, ['advance' => false, 'reference' => 'landlord:'.now()->getTimestampMs()]);
if ($guestConfirmed) {
$booking->forceFill(['guest_confirmed_at' => $booking->guest_confirmed_at ?? now()])->save();
}
+112
View File
@@ -0,0 +1,112 @@
<?php
namespace App\Actions;
use App\Channels\Mail\PortalMail;
use App\Communication\MessageMatcher;
use App\Enums\BookingTaskKind;
use App\Models\BookingTask;
use App\Models\InboundMessage;
use App\Models\Mailbox;
use App\Process\CaseLog;
use App\Support\Settings;
use Illuminate\Database\UniqueConstraintViolationException;
use Throwable;
/**
* The inbox of v0.11 (S2/S3, CH-01, CH-06, CH-08): every message of the landlord's dedicated mailbox is stored first,
* once per Message-ID. Booking notifications of the portals go unchanged through the existing portal path; every other
* message is assigned to a case by the deterministic rules or waits in the inbox for the landlord. A message never
* creates a case by itself. An assigned reply stops the reminders of the case's data request; its details are taken
* over only through the extraction and the common fact intake.
*/
class ReceiveInboundMessage
{
public function __construct(private ProcessPortalMail $portalMail, private MessageMatcher $matcher, private RequestCaseData $requests) {}
public function handle(PortalMail $mail, ?Mailbox $mailbox = null): InboundMessage
{
$existing = InboundMessage::query()->where('message_id', $mail->messageId)->first();
if ($existing !== null) {
return $existing;
}
try {
$message = InboundMessage::query()->create([
'mailbox_id' => $mailbox?->id,
'message_id' => $mail->messageId,
'in_reply_to' => $mail->inReplyTo,
'references' => $mail->references,
'from_address' => mb_strtolower($mail->from),
'from_name' => $mail->fromName,
'to_addresses' => $mail->to,
'subject' => mb_substr($mail->subject, 0, 500),
'body' => $mail->text,
'received_at' => $mail->receivedAt,
// CH §5 / M10: what arrives in test operation is marked as such.
'test_mode' => ! Settings::isLive(),
'status' => InboundMessage::NEW,
]);
} catch (UniqueConstraintViolationException) {
return InboundMessage::query()->where('message_id', $mail->messageId)->firstOrFail();
}
if ($this->portalMail->channelFor($mail->from) !== null) {
// A portal's notification: the existing portal path decides, unchanged (CH-08).
$record = $this->portalMail->handle($mail);
$record?->forceFill(['inbound_message_id' => $message->id])->save();
// CH-09/12: if the notification belongs to a case, the guest details it carries are evaluated for that case.
$bookingId = $record?->blockedPeriod()->value('linked_booking_id');
$message->update(['status' => InboundMessage::PORTAL, 'portal_email_id' => $record?->id, 'booking_id' => $bookingId, 'match_reason' => $bookingId ? 'portal_reference' : null, 'processed_at' => now()]);
return $message;
}
if ($this->isOwn($mail, $mailbox)) {
$message->update(['status' => InboundMessage::IGNORED, 'match_reason' => 'own', 'processed_at' => now()]);
return $message;
}
$match = $this->matcher->match($message);
if ($match['booking'] === null) {
$message->update(['status' => InboundMessage::NEEDS_REVIEW, 'hints' => $match['hints']]);
return $message;
}
$booking = $match['booking'];
$message->update(['status' => InboundMessage::ASSIGNED, 'booking_id' => $booking->id, 'match_reason' => $match['reason']]);
CaseLog::record($booking, 'mail_in', 'E-Mail des Gastes eingegangen'.($message->test_mode ? ' (im Testbetrieb)' : '').': '.$message->subject, actor: CaseLog::GUEST, at: $message->received_at);
$this->requests->replyReceived($booking);
BookingTask::openOnce($booking, BookingTaskKind::InboundReview, 'm'.$message->id, ['due_on' => today(), 'note' => '„'.mb_substr((string) $message->subject, 0, 120).'“ – im Posteingang ansehen; erkannte Angaben werden dort zur Übernahme vorgeschlagen.']);
// Evaluate at once instead of waiting for the next five-minute run (the run remains the safety net).
$this->evaluate($message);
return $message->refresh();
}
/**
* Runs the extraction for a freshly assigned message; a problem never undoes the assignment.
*/
public function evaluate(InboundMessage $message): void
{
try {
app(ExtractMessageFacts::class)->handle($message->refresh());
} catch (Throwable $exception) {
report($exception);
}
}
/**
* Our own mails (copies, loops) are not guest messages.
*/
private function isOwn(PortalMail $mail, ?Mailbox $mailbox): bool
{
$own = array_filter(array_map(fn (?string $address): string => mb_strtolower(trim((string) $address)), [
$mailbox?->address, config('mail.from.address'), Settings::tenant()?->sender_email,
]));
return in_array(mb_strtolower($mail->from), $own, true);
}
}
+83 -16
View File
@@ -3,17 +3,27 @@
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\Payment;
use App\Pricing\CaseMoney;
use App\Process\CaseClosure;
use App\Process\CaseLog;
use App\Support\Money;
use Carbon\CarbonInterface;
use Illuminate\Support\Facades\DB;
/**
* Records a payment of a case with its kind (package 8): the guest paid us, the portal reports the guest paid it, the
* portal paid out to us, or we refunded the guest. Only the guest's payments move the booking along
* (Bestätigt → Anzahlung erhalten → Bezahlt); a refund is stored as a negative amount.
* portal paid out to us, or we refunded the guest. A refund is stored as a negative amount.
*
* Only money of the guest that arrived on our account moves the booking along (Bestätigt → Anzahlung erhalten →
* Bezahlt). "Paid according to the portal" and a payout of the portal are facts of their own: they appear in the money
* overview and the history with their own words, never as "Anzahlung erhalten" (package 9, Abschnitt 5).
*/
class RecordPayment
{
@@ -21,7 +31,7 @@ public function handle(Booking $booking, int $amount, CarbonInterface $paidOn, P
{
$amount = $kind === PaymentKind::Refund ? -abs($amount) : $amount;
return DB::transaction(function () use ($booking, $amount, $paidOn, $method, $note, $recordedBy, $kind, $source): Payment {
$payment = DB::transaction(function () use ($booking, $amount, $paidOn, $method, $note, $recordedBy, $kind, $source): Payment {
$payment = $booking->payments()->create([
'amount' => $amount,
'paid_on' => $paidOn->toDateString(),
@@ -34,27 +44,84 @@ public function handle(Booking $booking, int $amount, CarbonInterface $paidOn, P
$booking->unsetRelation('payments');
$this->updateStatus($booking);
$this->settleTasks($booking, $kind, $recordedBy ?? CaseLog::actor());
return $payment;
});
CaseClosure::refresh($booking->fresh());
return $payment;
}
public function updateStatus(Booking $booking): void
{
$paymentStatuses = [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid];
if (! in_array($booking->status, $paymentStatuses, true)) {
return;
}
$paid = $booking->paidAmount();
$status = match (true) {
$paid >= $booking->total => BookingStatus::Paid,
$paid >= $booking->deposit && $paid > 0 => BookingStatus::DepositPaid,
default => BookingStatus::Confirmed,
};
if ($status !== $booking->status) {
$status = self::statusFor($booking);
if ($status !== null && $status !== $booking->status) {
$booking->update(['status' => $status]);
}
}
/**
* The payment status the booking should have by the guest's money on our account, or null when payments do not move
* this booking (not binding, closed, cancelled).
*/
public static function statusFor(Booking $booking): ?BookingStatus
{
if (! in_array($booking->status, [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid], true)) {
return null;
}
$paid = $booking->paidToUs();
return match (true) {
$booking->total !== null && $booking->total > 0 && $paid >= $booking->total => BookingStatus::Paid,
$booking->deposit !== null && $paid >= $booking->deposit && $paid > 0 => BookingStatus::DepositPaid,
default => BookingStatus::Confirmed,
};
}
/**
* The history line in the words of what really happened.
*/
public static function summary(Booking $booking, PaymentKind $kind, int $amount, CarbonInterface $paidOn, ?string $source): string
{
$portal = $source ?: ($booking->processChannel()?->name ?? 'Portal');
return match ($kind) {
PaymentKind::Guest => 'Zahlung des Gastes auf unserem Konto eingegangen: '.Money::format($amount),
PaymentKind::GuestViaPortal => 'Laut '.$portal.' hat der Gast '.Money::format($amount).' an das Portal gezahlt – noch kein Geld bei uns',
PaymentKind::PortalPayout => 'Auszahlung von '.$portal.' auf unserem Konto eingegangen: '.Money::format($amount),
PaymentKind::Refund => 'Erstattung an den Gast: '.Money::format(abs($amount)),
}.' (vom '.$paidOn->format('d.m.Y').')';
}
/**
* Tasks that the payment settles: the payout check once nothing is outstanding, the claim after the stay once the
* guest owes nothing more.
*/
private function settleTasks(Booking $booking, PaymentKind $kind, string $by): void
{
$money = CaseMoney::of($booking);
$open = fn (BookingTaskKind $taskKind) => BookingTask::query()->where('booking_id', $booking->id)->where('kind', $taskKind)->where('status', BookingTaskStatus::Open)->get();
if ($kind === PaymentKind::PortalPayout) {
$payout = $money->payout();
if (($payout['outstanding'] ?? 0) === 0) {
$open(BookingTaskKind::PayoutCheck)->each->complete($by, 'Auszahlung erfasst: '.Money::format($payout['received']).'.');
}
}
if (in_array($kind, [PaymentKind::Guest, PaymentKind::GuestViaPortal], true)) {
// A reminder that is no longer needed is closed by the payment itself.
if ($booking->openDeposit() === 0) {
$open(BookingTaskKind::DepositReminder)->each->complete($by, 'Anzahlung eingegangen.');
}
if ($booking->openAmount() === 0) {
foreach ([BookingTaskKind::BalanceRequest, BookingTaskKind::BalanceReminder, BookingTaskKind::OpenClaim] as $settled) {
$open($settled)->each->complete($by, 'Betrag vollständig erhalten.');
}
}
}
}
}
+343
View File
@@ -0,0 +1,343 @@
<?php
namespace App\Actions;
use App\Documents\DocumentReleases;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\DataRequestMode;
use App\Enums\DocumentKind;
use App\Enums\FactSource;
use App\Enums\IntakeKind;
use App\Mail\DataRequested;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\DataRequest;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use App\Process\FactContribution;
use App\Support\Settings;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\URL;
use Throwable;
/**
* The data request of v0.11 (S1, S4, CH-04, CH-15–CH-18): when the next step of a case lacks details, the guest is
* asked – automatically, prepared for the landlord's release, or by the landlord himself, as the case's settings say.
* At most one request runs per case. A partial answer leads to a targeted follow-up question, silence to reminders;
* both have their own limits and counters that are never reset. At the limit the landlord takes over.
*
* The request decides nothing about the case: answers go through the common fact intake, which asks the existing
* process to carry on. It never touches a hold or a deadline of the offer (CH-16/17, architecture test).
*/
class RequestCaseData
{
/** What the details are needed for. */
public const FOR_OFFER = 'offer';
public const FOR_WISH = 'wish_confirmation';
public const FOR_BOOKING = 'booking';
/**
* What the case needs next and which details are missing for it, or null when nothing is to be asked.
*
* @return array{purpose: string, fields: list<string>}|null
*/
public static function needs(Booking $booking): ?array
{
$booking->loadMissing('guest');
if (in_array($booking->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true) || $booking->isInternal()) {
return null;
}
if ($booking->isBinding()) {
// A binding booking (also from a portal, E-036) stays binding; only administrative guest details are asked for.
if ($booking->departure->isPast()) {
return null;
}
$fields = array_values(array_filter(CaseRequirements::missing($booking), fn (string $field): bool => str_starts_with($field, 'guest.')));
return $fields === [] ? null : ['purpose' => self::FOR_BOOKING, 'fields' => $fields];
}
if ($booking->intake === IntakeKind::Booking || $booking->status !== BookingStatus::Reserved || $booking->offer_version > 0) {
return null;
}
$purpose = match (true) {
$booking->process()->preReservation() => self::FOR_OFFER,
$booking->wish_at !== null => self::FOR_WISH,
default => null,
};
if ($purpose === null) {
return null;
}
$fields = CaseRequirements::missing($booking, $purpose === self::FOR_WISH ? CaseRequirements::WISH_CONFIRMATION : CaseRequirements::OFFER);
return $fields === [] ? null : ['purpose' => $purpose, 'fields' => $fields];
}
/**
* Starts the request for the next step if details are missing and none runs yet. Returns the running request.
*/
public function forNextStep(Booking $booking, ?DataRequestMode $mode = null): ?DataRequest
{
$needs = self::needs($booking);
// Without an e-mail address there is no way back to the guest: the case shows "enter the contact details".
if ($needs === null || ! CaseRequirements::isValid('guest.email', $booking->guest?->email)) {
return null;
}
$request = DB::transaction(function () use ($booking, $needs, $mode): DataRequest {
$booking->lockForTransition();
$running = $booking->openDataRequest();
if ($running !== null) {
return $running;
}
$mode ??= $booking->process()->dataRequestMode();
return $booking->dataRequests()->create([
'tenant_id' => $booking->tenant_id,
'status' => match (true) {
$mode === DataRequestMode::Manual => DataRequest::MANUAL,
$mode === DataRequestMode::Automatic && self::mayGoOutAutomatically() => DataRequest::OPEN,
default => DataRequest::DRAFT,
},
'mode' => $mode,
'purpose' => $needs['purpose'],
'fields' => $needs['fields'],
'last_message' => DataRequest::INITIAL,
]);
});
if ($request->wasRecentlyCreated) {
CaseLog::record($booking, 'data_request', match ($request->status) {
DataRequest::OPEN => 'Fehlende Angaben werden beim Gast angefragt',
DataRequest::DRAFT => 'Rückfrage nach fehlenden Angaben vorbereitet – wartet auf Ihre Freigabe',
default => 'Fehlende Angaben: bitte selbst beim Gast nachfragen (Textvorschlag im Vorgang)',
}, data: ['fields' => $request->fields], actor: CaseLog::SYSTEM);
if ($request->status === DataRequest::OPEN) {
$this->send($request, DataRequest::INITIAL);
}
}
return $request;
}
/**
* The landlord releases the prepared question (or asks now although the case is set to manual).
*/
public function approve(DataRequest $request): bool
{
if (! $request->isRunning()) {
return false;
}
if (! CaseRequirements::isValid('guest.email', $request->booking->guest?->email)) {
return false;
}
$kind = $request->last_message === DataRequest::FOLLOWUP ? DataRequest::FOLLOWUP : DataRequest::INITIAL;
$request->update(['status' => DataRequest::OPEN]);
return $this->send($request, $kind);
}
/**
* Sends the question, follow-up or reminder. A failing mail is shown in the case; the landlord takes over.
*/
public function send(DataRequest $request, string $kind): bool
{
$booking = $request->booking()->with(['guest', 'property'])->firstOrFail();
$profile = $booking->process();
$needs = self::needs($booking);
if ($needs === null) {
$this->close($request, DataRequest::COMPLETED, 'alle Angaben da');
return false;
}
$request->fields = $needs['fields'];
if ($kind === DataRequest::FOLLOWUP) {
$request->followups_sent++;
$request->link_version++;
}
if ($kind === DataRequest::REMINDER) {
$request->reminders_sent++;
}
try {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new DataRequested($booking, $request, $kind, $this->url($request, $booking)));
} catch (Throwable $exception) {
Log::warning('Rückfrage nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
$request->forceFill(['status' => DataRequest::MANUAL])->save();
BookingTask::openOnce($booking, BookingTaskKind::GuestUnresponsive, 'r'.$request->id, ['due_on' => today(), 'note' => 'Die Rückfrage konnte nicht zugestellt werden – bitte die E-Mail-Adresse prüfen oder selbst nachfragen.']);
CaseLog::record($booking, 'data_request', 'Rückfrage konnte nicht zugestellt werden', actor: CaseLog::SYSTEM);
return false;
}
$request->forceFill([
'status' => DataRequest::OPEN,
'last_message' => $kind,
'last_sent_at' => now(),
'response_due_at' => now()->addHours($profile->reminderHours()),
'next_reminder_at' => now()->addHours($profile->reminderHours()),
])->save();
CaseLog::record($booking, 'data_request', match ($kind) {
DataRequest::FOLLOWUP => 'Gezielte Folgefrage an den Gast ('.$request->followups_sent.'.)',
DataRequest::REMINDER => 'Erinnerung an den Gast ('.$request->reminders_sent.'.)',
default => 'Rückfrage an den Gast gesendet',
}.': '.implode(', ', CaseRequirements::labels($request->fields)), actor: CaseLog::SYSTEM);
return true;
}
/**
* Details arrived (any source): the open reminder is cancelled; if everything is there the request ends, otherwise
* a targeted follow-up question follows within its limit (CH-15–17). The landlord's own entries never trigger a
* question to the guest.
*/
public function answered(Booking $booking, FactContribution $contribution, FactSource $source): void
{
$request = $booking->openDataRequest();
if ($request === null) {
return;
}
$needs = self::needs($booking->refresh());
if ($needs === null) {
$this->close($request, DataRequest::COMPLETED, 'alle Angaben da');
return;
}
if ($source->isAuthoritative() && $request->status === DataRequest::OPEN && $request->next_reminder_at === null && $request->followups_sent < $booking->process()->followupsMax()) {
// The landlord took over the guest's e-mail answer and something is still missing: a follow-up question is
// prepared for his release.
$request->forceFill(['status' => DataRequest::DRAFT, 'last_message' => DataRequest::FOLLOWUP, 'fields' => $needs['fields']])->save();
return;
}
if ($source->isAuthoritative() || $request->status !== DataRequest::OPEN || (! $contribution->anyApplied() && ! $contribution->needsReview())) {
$request->update(['fields' => $needs['fields']]);
return;
}
$request->forceFill(['answered_at' => now(), 'next_reminder_at' => null, 'fields' => $needs['fields']])->save();
if ($request->followups_sent >= $booking->process()->followupsMax()) {
$this->handOver($request, 'Antwort weiterhin unvollständig – die Grenze der Folgefragen ist erreicht.');
return;
}
if ($request->mode === DataRequestMode::Automatic && self::mayGoOutAutomatically()) {
$this->send($request, DataRequest::FOLLOWUP);
return;
}
$request->forceFill(['status' => $request->mode === DataRequestMode::Manual ? DataRequest::MANUAL : DataRequest::DRAFT, 'last_message' => DataRequest::FOLLOWUP])->save();
CaseLog::record($booking, 'data_request', 'Antwort unvollständig – Folgefrage vorbereitet: '.implode(', ', CaseRequirements::labels($needs['fields'])), actor: CaseLog::SYSTEM);
}
/**
* A reply of the guest arrived (assigned by the inbox): the open reminder is cancelled (CH-17). What it says is
* taken over only through the extraction and the fact intake.
*/
public function replyReceived(Booking $booking): void
{
$request = $booking->openDataRequest();
if ($request?->status !== DataRequest::OPEN) {
return;
}
$request->forceFill(['answered_at' => now(), 'next_reminder_at' => null])->save();
CaseLog::record($booking, 'data_request', 'Antwort des Gastes per E-Mail – Erinnerungen ruhen', actor: CaseLog::SYSTEM);
}
/**
* Due reminders of every running request (scheduler). At the limit the landlord takes over; nothing changes any
* deadline of the case.
*/
public function remindDue(): int
{
$count = 0;
$due = DataRequest::query()->where('status', DataRequest::OPEN)->whereNotNull('next_reminder_at')->where('next_reminder_at', '<=', now())->with('booking')->get();
foreach ($due as $request) {
$booking = $request->booking;
if ($booking === null || self::needs($booking) === null) {
$this->close($request, $booking === null ? DataRequest::STOPPED : DataRequest::COMPLETED, $booking === null ? 'Vorgang entfernt' : 'nichts mehr offen');
continue;
}
if ($request->reminders_sent >= $booking->process()->remindersMax()) {
$this->handOver($request, 'Der Gast hat auf die Rückfrage und '.$request->reminders_sent.' Erinnerung(en) nicht geantwortet.');
continue;
}
$count += $this->send($request, DataRequest::REMINDER) ? 1 : 0;
}
return $count;
}
/**
* Ends the request (all details there, the case ended, or the landlord stopped it).
*/
public function close(DataRequest $request, string $status, string $reason): void
{
if (! $request->isRunning()) {
return;
}
$request->forceFill(['status' => $status, 'closed_at' => now(), 'closed_reason' => $reason, 'next_reminder_at' => null])->save();
BookingTask::query()->where('booking_id', $request->booking_id)->where('kind', BookingTaskKind::GuestUnresponsive)->where('subject', 'r'.$request->id)->where('status', BookingTaskStatus::Open)
->get()->each(fn (BookingTask $task): bool => $task->forceFill(['status' => BookingTaskStatus::Done, 'completed_at' => now(), 'note' => trim($task->note.' · '.$reason)])->save());
if ($request->booking !== null) {
CaseLog::record($request->booking, 'data_request', 'Rückfrage beendet: '.$reason, actor: CaseLog::actor() ?? CaseLog::SYSTEM);
}
}
/**
* The guest's signed link to the form; it belongs to this request and its current version.
*/
public function url(DataRequest $request, ?Booking $booking = null): string
{
$booking ??= $request->booking;
$parameters = ['booking' => $booking, 'r' => $request->id, 'v' => $request->link_version];
$until = CarbonImmutable::now()->addDays($booking->process()->guestLinkValidDays());
return $booking->website()?->temporarySignedRoute('guest-data.show', $until, $parameters)
?? URL::temporarySignedRoute('guest-data.show', $until, $parameters);
}
/**
* Whether a question may go out without the landlord's click: its texts are released, or mails only reach the test
* recipient anyway (as for the automatic offer).
*/
public static function mayGoOutAutomatically(): bool
{
return DocumentReleases::isReleased(DocumentKind::DataRequest) || ! Settings::isLive();
}
private function handOver(DataRequest $request, string $note): void
{
$request->forceFill(['status' => DataRequest::MANUAL, 'next_reminder_at' => null])->save();
BookingTask::openOnce($request->booking, BookingTaskKind::GuestUnresponsive, 'r'.$request->id, ['due_on' => today(), 'note' => $note]);
CaseLog::record($request->booking, 'data_request', 'Rückfrage an Sie übergeben: '.$note, actor: CaseLog::SYSTEM);
}
}
+8 -8
View File
@@ -17,7 +17,8 @@
* Daily booking workflow. Payments are never chased automatically: due payments become tasks for the landlord
* (BookingTask, once per booking and kind) who checks the payment and sends the reminder on a click
* ({@see SendPaymentReminder}). Only the arrival information goes out by itself, once per booking, the configured
* number of days before arrival. Completion after departure.
* number of days before arrival. Preparation of the stays and their closing after departure ({@see PrepareStays},
* {@see CloseStay}).
*/
class SendBookingReminders
{
@@ -27,7 +28,7 @@ class SendBookingReminders
private const ARRIVAL_INFO_MAX_DAYS_BEFORE = 14;
/**
* @return array{deposit_overdue: int, balance_request: int, balance_overdue: int, arrival_info: int, completed: int}
* @return array{deposit_overdue: int, balance_request: int, balance_overdue: int, arrival_info: int, completed: int, prepared: int}
*/
public function handle(): array
{
@@ -68,18 +69,17 @@ public function handle(): array
$booking->update(['arrival_info_sent_at' => now()]);
}
$completed = Booking::query()
->where('status', BookingStatus::Paid)
->whereDate('departure', '<', $today)
->get();
$completed->each->update(['status' => BookingStatus::Completed]);
// Package 9: prepare the coming stays, close the stays whose departure has passed (open money stays as follow-up).
$prepared = app(PrepareStays::class)->handle();
$completed = app(CloseStay::class)->due();
return [
'deposit_overdue' => $depositTasks,
'balance_request' => $requestTasks,
'balance_overdue' => $overdueTasks,
'arrival_info' => $arrivals->count(),
'completed' => $completed->count(),
'completed' => $completed,
'prepared' => $prepared['arrival_details'] + $prepared['stay_tasks'],
];
}
+186
View File
@@ -0,0 +1,186 @@
<?php
namespace App\Actions;
use App\Availability\AvailabilityChecker;
use App\Documents\DocumentComposer;
use App\Documents\OfferTerms;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\DocumentKind;
use App\Enums\InboxMessageKind;
use App\Exceptions\ReservationException;
use App\Filament\Resources\Bookings\BookingResource;
use App\Mail\InformationSent;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\CaseLog;
use App\Support\Inbox;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\URL;
use Throwable;
/**
* Package 7 (E-026, P02 "Haltefrist = 0"): answers a request that reserves nothing with an information "unter Vorbehalt" –
* price and availability as checked now, no reservation and no acceptance link that could conclude a contract. The guest
* gets a signed link to ask for the booking ({@see SubmitBookingWish}); everything is checked again then.
*
* Sending again replaces the previous information: older links stop working and a booking wish made on them is void.
*/
class SendInformation
{
public function __construct(
private SendOffer $offer,
private AvailabilityChecker $availability,
private Inbox $inbox,
) {}
/**
* @param array{arrival?: string, departure?: string, guests?: int, promo_code?: ?string, price_adjustment?: ?int, price_adjustment_label?: ?string, valid_until?: ?string, offer_message?: ?string, contract_template_id?: int|string|null, annex_ids?: ?list<int|string>, guest?: array<string, ?string>, acknowledged?: bool, expected_version?: ?int} $changes
*
* @throws QuoteException
* @throws ReservationException
*/
public function handle(Booking $booking, array $changes = [], bool $sendMail = true): Booking
{
if ($sendMail && blank($booking->guest?->email)) {
throw new ReservationException('Vor dem E-Mail-Versand bitte die E-Mail-Adresse des zugeordneten Gastes ergänzen.');
}
$toConfirm = app(DocumentComposer::class)->compose($booking, DocumentKind::Information, $changes)->toConfirm();
if ($toConfirm !== [] && ! ($changes['acknowledged'] ?? false)) {
throw new ReservationException('Bitte die Hinweise prüfen und ausdrücklich bestätigen: '.implode(' ', $toConfirm));
}
DB::transaction(function () use ($booking, $changes): void {
$booking->lockForTransition();
if (! in_array($booking->status, [BookingStatus::Reserved, BookingStatus::Expired], true) || $booking->isHoldActive()) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'als Auskunft beantwortet');
}
if (isset($changes['expected_version']) && $booking->information_version !== (int) $changes['expected_version']) {
throw new ReservationException('Inzwischen wurde schon eine Auskunft gesendet (Version '.$booking->information_version.'). Es wurde nichts erneut gesendet.');
}
$arrival = CarbonImmutable::parse($changes['arrival'] ?? $booking->arrival);
$departure = CarbonImmutable::parse($changes['departure'] ?? $booking->departure);
if (! $this->availability->isAvailable($booking->property, $arrival, $departure, ignore: $booking)) {
throw ReservationException::notAvailable();
}
$promoCode = array_key_exists('promo_code', $changes) ? (filled($changes['promo_code']) ? trim((string) $changes['promo_code']) : null) : $booking->promo_code;
$stay = new StayRequest($arrival, $departure, (int) ($changes['guests'] ?? $booking->guests), $booking->extras ?? [], $promoCode);
$adjustment = (int) ($changes['price_adjustment'] ?? 0);
$adjustmentLabel = trim((string) ($changes['price_adjustment_label'] ?? '')) ?: ($adjustment < 0 ? 'Nachlass' : 'Zuschlag');
$quote = $this->offer->quoteFor($booking, $stay, $adjustment, $adjustmentLabel);
if (filled($changes['guest'] ?? null)) {
$booking->guest->update(Arr::only(array_map(fn ($value) => filled($value) ? trim((string) $value) : null, $changes['guest']), ['first_name', 'last_name', 'phone', 'street', 'postal_code', 'city', 'country']));
}
$validUntil = filled($changes['valid_until'] ?? null) ? CarbonImmutable::parse($changes['valid_until']) : now()->addHours($booking->process()->holdHours());
$booking->update([
'status' => BookingStatus::Reserved,
'hold_expires_at' => null,
'arrival' => $arrival->toDateString(),
'departure' => $departure->toDateString(),
'guests' => $stay->guests,
'promo_code' => $quote->promoCodeApplied ? $promoCode : null,
'price_adjustment' => $adjustment !== 0 ? $adjustment : null,
'price_adjustment_label' => $adjustment !== 0 ? $adjustmentLabel : null,
'quote' => $quote->toArray(),
'total' => $quote->total(),
'deposit' => $quote->deposit(),
'balance_due_on' => $quote->balanceDueOn->toDateString(),
'information_version' => $booking->information_version + 1,
'information_sent_at' => now(),
'information_valid_until' => $validUntil,
'offer_message' => $changes['offer_message'] ?? null,
'offer_terms' => OfferTerms::capture(OfferTerms::templateFor($booking, $changes['contract_template_id'] ?? null), $booking, array_key_exists('annex_ids', $changes) && is_array($changes['annex_ids']) ? array_map('intval', $changes['annex_ids']) : null),
// A wish on an older information is void; the guest asks again on the new one.
'wish_at' => null,
'wish' => null,
]);
$booking->refresh();
$booking->update(['information' => [
'version' => $booking->information_version,
'sent_at' => $booking->information_sent_at?->toIso8601String(),
'valid_until' => $validUntil->toIso8601String(),
'total' => $booking->total,
'quote_sha256' => self::quoteHash($booking),
'terms_sha256' => hash('sha256', json_encode($booking->offer_terms['texts'] ?? [])),
]]);
BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::BookingWish)->where('status', BookingTaskStatus::Open)
->update(['status' => BookingTaskStatus::Dismissed, 'note' => 'Durch eine neue Auskunft ersetzt.', 'completed_at' => now(), 'completed_by' => CaseLog::actor()]);
});
$booking->refresh();
CaseLog::record($booking, 'document', 'Auskunft unter Vorbehalt Version '.$booking->information_version.' erstellt (Preis '.Money::format((int) $booking->total).', ohne Reservierung)', data: array_filter([
'kind' => DocumentKind::Information->value,
'template' => $booking->offer_terms['template'] ?? null,
'information' => $booking->information,
'confirmed' => $toConfirm,
]));
if ($sendMail) {
$this->deliver($booking);
}
return $booking;
}
/**
* Sends the information mail; a failing mail server keeps the saved information and is reported in the inbox.
*
* @throws ReservationException
*/
public function deliver(Booking $booking): void
{
try {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new InformationSent($booking, $this->informationUrl($booking)));
} catch (Throwable $exception) {
Log::warning('Auskunft nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
$this->inbox->post(
InboxMessageKind::OfferMailFailed,
'booking-'.$booking->id.':i'.$booking->information_version,
'Auskunft '.$booking->reference.' nicht zugestellt',
'Die Auskunft ist gespeichert, aber die E-Mail konnte nicht versendet werden. Auf der Vorgangsseite kann der Link kopiert und dem Gast anders übermittelt werden.',
actionUrl: BookingResource::getUrl('view', ['record' => $booking]),
propertyId: $booking->property_id,
);
throw new ReservationException('Die Auskunft wurde gespeichert, aber die E-Mail konnte nicht versendet werden.');
}
}
/**
* The guest's link to the information page; valid while the information is valid and only for this version.
*/
public function informationUrl(Booking $booking): string
{
$parameters = ['booking' => $booking, 'v' => $booking->information_version];
$until = $booking->information_valid_until ?? now()->addDay();
return $booking->website()?->temporarySignedRoute('information.show', $until, $parameters)
?? URL::temporarySignedRoute('information.show', $until, $parameters);
}
/**
* Fingerprint of the price lines the guest was told.
*/
public static function quoteHash(Booking $booking): string
{
return hash('sha256', json_encode([$booking->quote['lines'] ?? [], $booking->total, $booking->arrival?->toDateString(), $booking->departure?->toDateString(), $booking->guests]));
}
}
+7
View File
@@ -20,6 +20,7 @@
use App\Pricing\QuoteLine;
use App\Pricing\StayRequest;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use App\Support\Inbox;
use Carbon\CarbonImmutable;
use Illuminate\Support\Arr;
@@ -65,6 +66,11 @@ public function handle(Booking $booking, array $changes = [], bool $sendMail = t
throw ReservationException::invalidTransition($booking->status->getLabel(), 'als Angebot versendet');
}
// G2a (v0.11): never an own binding offer without the required details – not even confirmed by hand.
if (($missing = CaseRequirements::blocker($booking->loadMissing('guest'), CaseRequirements::OFFER)) !== null) {
throw new ReservationException($missing);
}
$toConfirm = app(DocumentComposer::class)->compose($booking, DocumentKind::Offer, $changes)->toConfirm();
if ($toConfirm !== [] && ! ($changes['acknowledged'] ?? false)) {
throw new ReservationException('Bitte die Hinweise prüfen und ausdrücklich bestätigen: '.implode(' ', $toConfirm));
@@ -111,6 +117,7 @@ public function handle(Booking $booking, array $changes = [], bool $sendMail = t
'deposit' => $quote->deposit(),
'balance_due_on' => $quote->balanceDueOn->toDateString(),
'hold_expires_at' => filled($changes['valid_until'] ?? null) ? CarbonImmutable::parse($changes['valid_until']) : now()->addHours($booking->process()->holdHours()),
'hold_purpose' => Booking::HOLD_OFFER,
'offer_version' => $booking->offer_version + 1,
'offer_sent_at' => now(),
'offer_message' => $changes['offer_message'] ?? null,
+260
View File
@@ -0,0 +1,260 @@
<?php
namespace App\Actions;
use App\Availability\AvailabilityChecker;
use App\Availability\CalendarClearance;
use App\Documents\DocumentComposer;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\DocumentKind;
use App\Enums\InboxMessageKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
use App\Filament\Resources\Bookings\BookingResource;
use App\Mail\BookingWishAnswered;
use App\Mail\BookingWishNotice;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\CaseAutomation;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use App\Support\Inbox;
use App\Support\Money;
use App\Support\Settings;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Throwable;
/**
* Package 7 (E-026, E-030): the guest asks for the booking from an information "unter Vorbehalt". Everything is checked
* again in one locked step – the whole stay still free, the imported portal calendars current, the price the guest was
* told still the price of today, the data for the booking complete. Then the effective processing decides:
* automatically the booking is confirmed at once (only when nothing at all stands in the way), otherwise the landlord
* gets the task "Buchungswunsch bestätigen?". When the dates were given away meanwhile, no booking comes about; the
* guest gets a friendly answer and the landlord a note.
*
* Asking again for the same information is harmless (no second booking, no second mail); a link of an older information
* no longer works.
*/
class SubmitBookingWish
{
public const CONFIRMED = 'confirmed';
public const PENDING = 'pending';
public const UNAVAILABLE = 'unavailable';
public const ALREADY = 'already';
public function __construct(
private SendOffer $offer,
private AvailabilityChecker $availability,
private CalendarClearance $clearance,
private ConfirmBooking $confirm,
private Inbox $inbox,
) {}
/**
* @return string one of the outcome constants
*
* @throws ReservationException when the link is outdated, expired or the request is no longer open
*/
public function handle(Booking $booking, int $version, ?string $ip = null): string
{
$booking->loadMissing(['guest', 'property']);
if ($this->alreadyAsked($booking, $version)) {
return self::ALREADY;
}
$this->ensureCurrent($booking, $version);
// Network access (calendar imports) stays outside the transaction.
rescue(fn () => $this->clearance->refresh($booking->property), report: false);
$stale = $this->clearance->staleImports($booking->property)->pluck('name')->all();
$outcome = DB::transaction(function () use ($booking, $version, $ip, $stale): string {
$booking->lockForTransition();
if ($this->alreadyAsked($booking, $version)) {
return self::ALREADY;
}
$this->ensureCurrent($booking, $version);
$record = [
'information_version' => $version,
'at' => now()->toIso8601String(),
'ip_hash' => $ip !== null ? hash('sha256', $ip.config('app.key')) : null,
'total_told' => $booking->information['total'] ?? $booking->total,
'terms_sha256' => $booking->information['terms_sha256'] ?? null,
'via' => 'information_link',
];
if (! $this->availability->isAvailable($booking->property, $booking->arrival, $booking->departure, ignore: $booking)) {
$booking->update([
'wish_at' => now(),
'wish' => [...$record, 'outcome' => self::UNAVAILABLE, 'findings' => ['Der Zeitraum ist inzwischen vergeben.']],
'status' => BookingStatus::Declined,
'declined_by' => 'us',
]);
return self::UNAVAILABLE;
}
$findings = $this->findings($booking, $stale);
$automatic = $booking->processingMode() === ProcessingMode::Automatic;
$booking->update([
'wish_at' => now(),
'wish' => [...$record, 'total_now' => $findings['total_now'], 'findings' => $findings['findings'], 'outcome' => $automatic && $findings['findings'] === [] ? self::CONFIRMED : self::PENDING],
]);
if ($automatic && $findings['findings'] === []) {
$this->confirm->bind($booking);
$booking->update([
'accepted_at' => now(),
'acceptance' => [
'via' => 'booking_wish',
'information_version' => $version,
'wish_at' => $booking->wish_at?->toIso8601String(),
'total' => $booking->total,
'quote_sha256' => SendInformation::quoteHash($booking),
'terms_sha256' => $record['terms_sha256'],
'confirmed_by' => 'automatisch nach erneuter Prüfung',
],
]);
return self::CONFIRMED;
}
BookingTask::openOnce($booking, BookingTaskKind::BookingWish, 'v'.$version, [
'due_on' => today(),
'note' => $findings['findings'] === [] ? 'Zeitraum frei, Preis unverändert.' : implode(' ', $findings['findings']),
]);
return self::PENDING;
});
$booking->refresh();
CaseLog::record($booking, 'wish', match ($outcome) {
self::CONFIRMED => 'Buchungswunsch des Gastes – automatisch geprüft und verbindlich bestätigt',
self::PENDING => 'Buchungswunsch des Gastes eingegangen – wartet auf Ihre Bestätigung',
self::UNAVAILABLE => 'Buchungswunsch des Gastes – Zeitraum inzwischen vergeben, keine Buchung',
default => 'Buchungswunsch wiederholt (ohne Wirkung)',
}, data: $outcome === self::ALREADY ? [] : ['wish' => $booking->wish], actor: CaseLog::GUEST);
$this->notify($booking, $outcome);
// v0.11 (B3): the binding confirmation needs every detail – ask the guest for what is missing.
if ($outcome === self::PENDING) {
rescue(fn () => app(RequestCaseData::class)->forNextStep($booking->fresh()), report: true);
}
return $outcome;
}
/**
* Checks that the page shows the form for: the information is the current one, still valid and the request open.
*
* @throws ReservationException
*/
public function ensureCurrent(Booking $booking, int $version): void
{
if ($booking->information_version === 0 || $version !== $booking->information_version) {
throw new ReservationException('Diese Auskunft ist nicht mehr aktuell – wir haben Ihnen inzwischen eine neuere gesendet. Bitte verwenden Sie den Link aus der neuesten E-Mail.');
}
if ($booking->wish_at !== null) {
throw new ReservationException('Zu dieser Auskunft liegt Ihr Buchungswunsch bereits vor.');
}
if ($booking->status !== BookingStatus::Reserved) {
throw new ReservationException(in_array($booking->status, BookingStatus::occupying(), true)
? 'Ihre Buchung ist bereits verbindlich bestätigt – Sie müssen nichts weiter tun.'
: 'Diese Anfrage ist abgeschlossen. Gern können Sie über unsere Webseite neu anfragen.');
}
if (! $booking->information_valid_until?->isFuture()) {
throw new ReservationException('Diese Auskunft ist abgelaufen. Gern können Sie über unsere Webseite neu anfragen; wir prüfen dann Preis und Verfügbarkeit erneut.');
}
}
/**
* Everything that keeps the wish from being confirmed automatically, and the price of today.
*
* @param list<string> $stale names of portals whose calendar is not current
* @return array{findings: list<string>, total_now: ?int}
*/
public function findings(Booking $booking, array $stale = []): array
{
$findings = [];
$totalNow = null;
try {
$label = (string) ($booking->price_adjustment_label ?: 'Zuschlag');
$quote = $this->offer->quoteFor($booking, new StayRequest($booking->arrival, $booking->departure, $booking->guests, $booking->extras ?? [], $booking->promo_code), (int) $booking->price_adjustment, $label);
$totalNow = $quote->total();
$told = (int) ($booking->information['total'] ?? $booking->total);
if ($totalNow !== $told) {
$findings[] = 'Der Preis hat sich seit der Auskunft geändert: damals '.Money::format($told).', heute '.Money::format($totalNow).'.';
}
} catch (QuoteException $exception) {
$findings[] = 'Der Preis lässt sich heute nicht berechnen: '.$exception->getMessage();
}
if ($stale !== []) {
$findings[] = 'Der Kalenderstand von '.implode(', ', $stale).' ist nicht aktuell.';
}
$findings = [...$findings, ...app(CaseAutomation::class)->documentBlockers($booking)];
if (($missing = CaseRequirements::blocker($booking, CaseRequirements::WISH_CONFIRMATION)) !== null) {
$findings[] = $missing;
}
if (! app(AutoOffer::class)->contractTextsReleased()) {
$findings[] = 'Mietbedingungen, Stornobedingungen oder Bankverbindung sind noch nicht vom Betreiber freigegeben (leer oder Mustertext).';
}
// What the confirmation with the contract would need to be confirmed by the landlord (unreleased texts, gaps).
foreach (app(DocumentComposer::class)->compose($booking, DocumentKind::Confirmation)->toConfirm() as $point) {
$findings[] = $point;
}
return ['findings' => array_values(array_unique($findings)), 'total_now' => $totalNow];
}
private function alreadyAsked(Booking $booking, int $version): bool
{
return $booking->wish_at !== null && ($booking->wish['information_version'] ?? null) === $version;
}
/**
* Mails after the commit; none of them can undo what was decided.
*/
private function notify(Booking $booking, string $outcome): void
{
if ($outcome === self::ALREADY) {
return;
}
if ($outcome === self::CONFIRMED) {
$this->confirm->deliver($booking);
}
try {
if ($outcome !== self::CONFIRMED && filled($booking->guest?->email)) {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new BookingWishAnswered($booking, $outcome));
}
Mail::to(Settings::notificationRecipients())->send(new BookingWishNotice($booking, $outcome));
} catch (Throwable $exception) {
Log::warning('Mail zum Buchungswunsch nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
}
if ($outcome === self::UNAVAILABLE) {
$this->inbox->post(
InboxMessageKind::OfferRejected,
'wish-'.$booking->id.':i'.$booking->information_version,
'Buchungswunsch '.$booking->reference.': Zeitraum inzwischen vergeben',
'Der Gast hat aus der Auskunft die Buchung angefragt, aber der Zeitraum ist inzwischen belegt. Es ist keine Buchung entstanden; der Gast hat eine freundliche Absage erhalten.',
actionUrl: BookingResource::getUrl('view', ['record' => $booking]),
propertyId: $booking->property_id,
);
}
}
}
+2
View File
@@ -97,6 +97,8 @@ public function handle(Property $property, Channel $channel, CarbonImmutable $ar
});
app(CaseAutomation::class)->advance($booking);
// v0.11 (E-036): the booking stays binding; only missing administrative details of a reachable guest are asked for.
rescue(fn () => app(RequestCaseData::class)->forNextStep($booking->fresh()), report: true);
return $booking->refresh();
}
+6 -1
View File
@@ -11,6 +11,7 @@
use App\Models\Channel;
use App\Process\CaseAutomation;
use App\Process\ProcessSettings;
use App\Process\RequestHold;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
@@ -41,8 +42,13 @@ public function handle(Channel $channel, CarbonImmutable $arrival, CarbonImmutab
}
$profile = $this->settings->resolve($property, $channel, IntakeKind::Inquiry);
// v0.11 (B1): a portal request without the guest's details holds nothing until the details are there; the
// offer hold comes with the offer.
$draft = new Booking(['property_id' => $property->id, 'arrival' => $arrival->toDateString(), 'departure' => $departure->toDateString()]);
$draft->setRelation('guest', null);
return $property->bookings()->create([
...RequestHold::for($draft, $profile),
'status' => BookingStatus::Reserved,
'source' => 'portal',
'intake' => IntakeKind::Inquiry,
@@ -50,7 +56,6 @@ public function handle(Channel $channel, CarbonImmutable $arrival, CarbonImmutab
'portal_reference' => $reference,
'arrival' => $arrival->toDateString(),
'departure' => $departure->toDateString(),
'hold_expires_at' => $profile->preReservation() ? now()->addHours($profile->holdHours()) : null,
'processing_mode' => $processingMode,
'internal_notes' => $notes,
]);
+100 -1
View File
@@ -7,7 +7,9 @@
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\Cache;
use Throwable;
use Webklex\PHPIMAP\Client;
use Webklex\PHPIMAP\ClientManager;
use Webklex\PHPIMAP\Folder;
use Webklex\PHPIMAP\Message;
/**
@@ -70,7 +72,7 @@ public function fetch(array $senders): array
'protocol' => 'imap',
]);
$client->connect();
$folder = $client->getFolderByPath($config['folder']);
$folder = self::folder($client, $config['folder']);
$mails = [];
foreach ($senders as $sender) {
@@ -98,6 +100,97 @@ public function fetch(array $senders): array
return $mails;
}
/**
* Every message of the last days (v0.11 inbox, mailbox mode "full"), left unread. Deduplication happens when the
* messages are stored.
*
* @return list<PortalMail>
*
* @throws ChannelSyncException
*/
public function fetchAll(): array
{
$config = self::configuration();
if ($config === null) {
throw new ChannelSyncException('Für diesen Mandanten ist kein Postfach hinterlegt.');
}
try {
$client = (new ClientManager)->make([
'host' => $config['host'], 'port' => $config['port'], 'encryption' => $config['encryption'], 'validate_cert' => true,
'username' => $config['username'], 'password' => $config['password'], 'protocol' => 'imap',
]);
$client->connect();
$messages = self::folder($client, $config['folder'])->query()
->whereSince(CarbonImmutable::today()->subDays((int) config('fewo.mailbox.lookback_days', 3)))
->leaveUnread()
->get();
$mails = [];
foreach ($messages as $message) {
$mails[] = $this->toPortalMail($message);
}
$client->disconnect();
} catch (Throwable $exception) {
Cache::forever(self::key(self::LAST_ERROR_KEY), $exception->getMessage());
throw new ChannelSyncException('Postfach konnte nicht gelesen werden: '.$exception->getMessage(), previous: $exception);
}
Cache::forever(self::key(self::LAST_SUCCESS_KEY), now()->toIso8601String());
Cache::forget(self::key(self::LAST_ERROR_KEY));
return $mails;
}
/**
* Connects with the given connection data and counts the messages of the last days (check on System › Betrieb).
* Nothing is read, marked or stored.
*
* @param array{host: string, port: int, encryption: string, username: string, password: ?string, folder: string} $config
*
* @throws ChannelSyncException
*/
public function probe(array $config): int
{
try {
$client = (new ClientManager)->make([
'host' => $config['host'], 'port' => $config['port'], 'encryption' => $config['encryption'], 'validate_cert' => true,
'username' => $config['username'], 'password' => $config['password'], 'protocol' => 'imap',
]);
$client->connect();
$count = self::folder($client, $config['folder'])->query()
->whereSince(CarbonImmutable::today()->subDays((int) config('fewo.mailbox.lookback_days', 3)))
->leaveUnread()->setFetchBody(false)->count();
$client->disconnect();
} catch (Throwable $exception) {
throw new ChannelSyncException('Postfach nicht erreichbar: '.$exception->getMessage(), previous: $exception);
}
return (int) $count;
}
/**
* The folder to read. The inbox is called "INBOX" on the IMAP server, whatever the provider's web mail shows
* ("Posteingang", "Inbox"); other names match regardless of case. An unknown name names the existing folders.
*
* @throws ChannelSyncException
*/
public static function folder(Client $client, ?string $name): Folder
{
$name = trim((string) $name);
$wanted = $name === '' || in_array(mb_strtolower($name), ['inbox', 'posteingang'], true) ? 'INBOX' : $name;
$folders = $client->getFolders(false);
$folder = $folders->first(fn (Folder $folder): bool => $folder->path === $wanted)
?? $folders->first(fn (Folder $folder): bool => mb_strtolower($folder->path) === mb_strtolower($wanted) || mb_strtolower($folder->name) === mb_strtolower($wanted));
if ($folder === null) {
throw new ChannelSyncException('Ordner „'.$name.'“ gibt es in diesem Postfach nicht. Vorhanden: '.$folders->map(fn (Folder $folder): string => $folder->path)->implode(', ').' (der Posteingang heißt „INBOX“).');
}
return $folder;
}
private function toPortalMail(Message $message): PortalMail
{
$text = $message->getTextBody();
@@ -108,12 +201,18 @@ private function toPortalMail(Message $message): PortalMail
$from = $message->getFrom()->first();
$date = $message->getDate()->first();
$references = preg_split('/\s+/', trim((string) $message->getReferences()?->first())) ?: [];
return new PortalMail(
messageId: (string) ($message->getMessageId()->first() ?: sha1($message->getSubject()->first().$date)),
from: (string) ($from->mail ?? ''),
subject: (string) $message->getSubject()->first(),
text: $text,
receivedAt: $date ? CarbonImmutable::instance($date) : CarbonImmutable::now(),
inReplyTo: ($reply = trim((string) $message->getInReplyTo()?->first())) !== '' ? $reply : null,
references: array_values(array_filter($references)),
to: collect($message->getTo()?->all() ?? [])->map(fn ($address): string => mb_strtolower((string) ($address->mail ?? '')))->filter()->values()->all(),
fromName: filled($from->personal ?? null) ? (string) $from->personal : null,
);
}
}
+10 -1
View File
@@ -5,15 +5,24 @@
use Carbon\CarbonImmutable;
/**
* An incoming e-mail as delivered by the mailbox reader or the n8n webhook.
* An incoming e-mail as delivered by the mailbox reader or the n8n webhook. The reply references, recipients and the
* sender's name are only filled when the whole mailbox is read (v0.11 inbox).
*/
final readonly class PortalMail
{
/**
* @param list<string> $references
* @param list<string> $to
*/
public function __construct(
public string $messageId,
public string $from,
public string $subject,
public string $text,
public CarbonImmutable $receivedAt,
public ?string $inReplyTo = null,
public array $references = [],
public array $to = [],
public ?string $fromName = null,
) {}
}
@@ -0,0 +1,9 @@
<?php
namespace App\Communication\Extraction;
/**
* The provider rejected the landlord's access (invalid key, no credit, no permission). The message never contains the
* key.
*/
class AccessRejected extends ExtractionFailed {}
+78
View File
@@ -0,0 +1,78 @@
<?php
namespace App\Communication\Extraction;
use App\Enums\TenantServiceKey;
use App\Models\Tenant;
use App\Models\TenantService;
use App\Tenancy\TenantFeatures;
/**
* A landlord's own AI access (bring your own key): provider, key and the two models of the extraction. There is no
* central operator key and no built-in model – without a complete access, or after the provider rejected the key,
* the extraction is off and messages go to the landlord.
*/
final class AiAccess
{
public const OK = 'ok';
public const INVALID = 'invalid';
public function __construct(
public readonly AiProvider $provider,
#[\SensitiveParameter] public readonly string $key,
public readonly string $smallModel,
public readonly string $reviewModel,
) {}
/**
* The usable access of a landlord, or null (service off, incomplete, or rejected by the provider).
*/
public static function for(?Tenant $tenant): ?self
{
if ($tenant === null || ! app(TenantFeatures::class)->enabled(TenantServiceKey::AiGuestMail, $tenant)) {
return null;
}
$service = self::service($tenant);
if ($service === null || $service->check_status === self::INVALID) {
return null;
}
return self::fromService($service);
}
/**
* The access as configured, regardless of the last check (for the check itself).
*/
public static function fromService(TenantService $service): ?self
{
$settings = (array) $service->settings;
$provider = AiProvider::tryFrom((string) ($settings['provider'] ?? ''));
$small = trim((string) ($settings['small_model'] ?? ''));
$review = trim((string) ($settings['review_model'] ?? ''));
if ($provider === null || blank($service->api_key) || $small === '' || $review === '') {
return null;
}
return new self($provider, (string) $service->api_key, $small, $review);
}
public static function service(Tenant $tenant): ?TenantService
{
return TenantService::query()->where('tenant_id', $tenant->id)->where('service', TenantServiceKey::AiGuestMail->value)->first();
}
/**
* The provider rejected the key: the extraction stays off until the landlord saves or checks the access again.
*/
public static function markInvalid(Tenant $tenant, string $message): void
{
self::service($tenant)?->forceFill(['check_status' => self::INVALID, 'check_message' => mb_substr($message, 0, 500), 'checked_at' => now()])->save();
}
public function __debugInfo(): array
{
return ['provider' => $this->provider->value, 'key' => '***', 'smallModel' => $this->smallModel, 'reviewModel' => $this->reviewModel];
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Communication\Extraction;
use Filament\Support\Contracts\HasLabel;
/**
* The AI providers a landlord may connect (bring your own key, v0.11). Endpoints are fixed here – no configuration,
* form or environment value can point the extraction at another host.
*/
enum AiProvider: string implements HasLabel
{
case Anthropic = 'anthropic';
case OpenRouter = 'openrouter';
public function getLabel(): string
{
return match ($this) {
self::Anthropic => 'Anthropic (Claude API)',
self::OpenRouter => 'OpenRouter',
};
}
public function endpoint(): string
{
return match ($this) {
self::Anthropic => 'https://api.anthropic.com/v1/messages',
self::OpenRouter => 'https://openrouter.ai/api/v1/chat/completions',
};
}
/**
* Examples for the form – suggestions only, nothing is preset.
*/
public function modelExamples(): string
{
return match ($this) {
self::Anthropic => 'z. B. klein „claude-haiku-5-5“, groß „claude-opus-5-5“',
self::OpenRouter => 'z. B. klein „anthropic/claude-haiku-5-5“, groß „anthropic/claude-opus-5-5“ (Kennung wie bei OpenRouter angezeigt)',
};
}
}
@@ -0,0 +1,11 @@
<?php
namespace App\Communication\Extraction;
use RuntimeException;
/**
* The extraction could not produce a usable result (no key, timeout, refusal, invalid output). The message then
* waits for the landlord – the safe fallback of CH-14.
*/
class ExtractionFailed extends RuntimeException {}
+143
View File
@@ -0,0 +1,143 @@
<?php
namespace App\Communication\Extraction;
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Http\Client\RequestException;
use Illuminate\Http\Client\Response;
use Illuminate\Support\Facades\Http;
use Throwable;
/**
* The model connection of the extraction with the landlord's own access (bring your own key, v0.11): Anthropic's
* Messages API or OpenRouter's chat completions, both over HTTP to the provider's fixed endpoint (AiProvider), no SDK
* dependency. One call: system prompt, the message, and a JSON schema the answer must follow (structured outputs).
* The key travels only in the request header; it is never part of an exception, a log line or a stored result.
*/
class LlmClient
{
/** Server-side refusal fallback on Anthropic (opt-in default for the Claude Opus family). */
private const ANTHROPIC_FALLBACK_BETA = 'server-side-fallback-2026-07-01';
/**
* @param array<string, mixed> $schema
* @return array{data: array<string, mixed>, model: string, usage: array<string, mixed>}
*
* @throws AccessRejected when the provider rejects the access
* @throws ExtractionFailed for every other unusable outcome
*/
public function structured(AiAccess $access, string $model, string $system, string $message, array $schema, string $effort = 'medium'): array
{
[$headers, $body] = match ($access->provider) {
AiProvider::Anthropic => $this->anthropic($access, $model, $system, $message, $schema, $effort),
AiProvider::OpenRouter => $this->openRouter($access, $model, $system, $message, $schema),
};
try {
$response = Http::withHeaders($headers)
->timeout((int) config('fewo.ai.timeout', 40))
// Only passing problems are repeated; a rejected key or a bad request is not.
->retry(2, 2000, fn (Throwable $exception): bool => $exception instanceof ConnectionException || ($exception instanceof RequestException && in_array($exception->response->status(), [429, 500, 502, 503, 529], true)), throw: false)
->post($access->provider->endpoint(), $body);
} catch (ConnectionException) {
throw new ExtractionFailed('Keine Verbindung zu '.$access->provider->getLabel().'.');
}
if (in_array($response->status(), [401, 402, 403], true)) {
throw new AccessRejected($access->provider->getLabel().' lehnt den Zugang ab ('.$response->status().': '.$this->providerMessage($response, $access).').');
}
if (! $response->successful()) {
throw new ExtractionFailed($access->provider->getLabel().' antwortet mit '.$response->status().' ('.$this->providerMessage($response, $access).').');
}
$payload = (array) $response->json();
$text = $access->provider === AiProvider::Anthropic ? $this->anthropicText($payload) : $this->openRouterText($payload);
$data = json_decode($text, true);
if (! is_array($data)) {
throw new ExtractionFailed('Die Antwort ist kein gültiges JSON.');
}
return ['data' => $data, 'model' => (string) ($payload['model'] ?? $model), 'usage' => (array) ($payload['usage'] ?? [])];
}
/**
* @param array<string, mixed> $schema
* @return array{0: array<string, string>, 1: array<string, mixed>}
*/
private function anthropic(AiAccess $access, string $model, string $system, string $message, array $schema, string $effort): array
{
$headers = ['x-api-key' => $access->key, 'anthropic-version' => (string) config('fewo.ai.anthropic_version'), 'content-type' => 'application/json'];
$body = [
'model' => $model,
'max_tokens' => 4096,
'system' => $system,
'messages' => [['role' => 'user', 'content' => $message]],
'output_config' => ['effort' => $effort, 'format' => ['type' => 'json_schema', 'schema' => $schema]],
];
if (str_starts_with($model, 'claude-opus-')) {
$body['fallbacks'] = 'default';
$headers['anthropic-beta'] = self::ANTHROPIC_FALLBACK_BETA;
}
return [$headers, $body];
}
/**
* @param array<string, mixed> $schema
* @return array{0: array<string, string>, 1: array<string, mixed>}
*/
private function openRouter(AiAccess $access, string $model, string $system, string $message, array $schema): array
{
return [
['Authorization' => 'Bearer '.$access->key, 'content-type' => 'application/json', 'HTTP-Referer' => (string) config('app.url'), 'X-OpenRouter-Title' => 'FewoPortal'],
[
'model' => $model,
'max_tokens' => 4096,
'messages' => [['role' => 'system', 'content' => $system], ['role' => 'user', 'content' => $message]],
'response_format' => ['type' => 'json_schema', 'json_schema' => ['name' => 'extraction', 'strict' => true, 'schema' => $schema]],
// Only providers that honour the schema; otherwise it would merely be a hint.
'provider' => ['require_parameters' => true],
],
];
}
/**
* @param array<string, mixed> $payload
*/
private function anthropicText(array $payload): string
{
match ($payload['stop_reason'] ?? null) {
'refusal' => throw new ExtractionFailed('Der Anbieter hat die Auswertung abgelehnt.'),
'max_tokens' => throw new ExtractionFailed('Die Antwort ist unvollständig.'),
default => null,
};
return collect((array) ($payload['content'] ?? []))->where('type', 'text')->pluck('text')->implode('');
}
/**
* @param array<string, mixed> $payload
*/
private function openRouterText(array $payload): string
{
$choice = (array) ($payload['choices'][0] ?? []);
match ($choice['finish_reason'] ?? null) {
'content_filter' => throw new ExtractionFailed('Der Anbieter hat die Auswertung abgelehnt.'),
'length' => throw new ExtractionFailed('Die Antwort ist unvollständig.'),
'error' => throw new ExtractionFailed('Der Anbieter meldet einen Fehler.'),
default => null,
};
return (string) ($choice['message']['content'] ?? '');
}
/**
* The provider's own short message, cut and without anything that looks like a key.
*/
private function providerMessage(Response $response, AiAccess $access): string
{
$message = str_replace($access->key, '***', (string) ($response->json('error.message') ?? $response->json('error.type') ?? ''));
return mb_substr((string) preg_replace('/(sk-[A-Za-z0-9_\-]{6})[A-Za-z0-9_\-]+/', '$1…', $message), 0, 200) ?: 'ohne Angabe';
}
}
@@ -0,0 +1,162 @@
<?php
namespace App\Communication\Extraction;
use App\Models\Booking;
use App\Models\InboundMessage;
use App\Process\CaseRequirements;
/**
* The model side of the extraction (v0.11, CH-14): versioned prompts with defined placeholders, a JSON schema for the
* answer and its validation here (the answer is checked, not trusted). The small model extracts; the review model
* sees the original and the first extraction – both as configured in the landlord's own access. Both only return
* candidates – nothing is stored or changed here.
*/
class MessageExtractor
{
public function __construct(private LlmClient $client) {}
/**
* @return array{data: array{facts: list<array{field: string, value: string, evidence: string, confidence: float|int}>, change_requests: list<array{field: string, value: string, evidence: string}>, intent: string, uncertainties: list<string>}, model: string}
*
* @throws ExtractionFailed
*/
public function extract(AiAccess $access, InboundMessage $message, Booking $booking): array
{
return $this->call($access, $access->smallModel, $this->prompt('', $booking), $this->messageText($message), 'medium');
}
/**
* @param array<string, mixed> $first
* @return array{data: array{facts: list<array{field: string, value: string, evidence: string, confidence: float|int}>, change_requests: list<array{field: string, value: string, evidence: string}>, intent: string, uncertainties: list<string>}, model: string}
*
* @throws ExtractionFailed
*/
public function review(AiAccess $access, InboundMessage $message, Booking $booking, array $first): array
{
return $this->call($access, $access->reviewModel, $this->prompt('-review', $booking, ['first_extraction' => json_encode($first, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT)]), $this->messageText($message), 'high');
}
public static function promptVersion(): string
{
return (string) config('fewo.ai.prompt_version', 'v1');
}
/**
* The prompt of the configured version with every placeholder filled; an unknown placeholder is an error.
*
* @param array<string, string> $extra
*/
public function prompt(string $variant, Booking $booking, array $extra = []): string
{
$path = resource_path('prompts/extraction/'.self::promptVersion().$variant.'.md');
if (! is_file($path)) {
throw new ExtractionFailed('Prompt '.self::promptVersion().$variant.' fehlt.');
}
$values = [
'phase' => match (true) {
$booking->isBinding() => 'binding booking (contract exists; changes are only wishes)',
$booking->offer_version > 0 => 'binding offer sent, not yet accepted',
default => 'non-binding request',
},
'requested_fields' => implode(', ', $booking->openDataRequest()?->fields ?? CaseRequirements::missing($booking)) ?: 'none',
'known_fields' => $this->knownFields($booking),
'today' => now()->toDateString(),
...$extra,
];
$prompt = preg_replace_callback('/\{\{\s*(\w+)\s*\}\}/', function (array $match) use ($values): string {
if (! array_key_exists($match[1], $values)) {
throw new ExtractionFailed('Unbekannter Platzhalter {{'.$match[1].'}}.');
}
return $values[$match[1]];
}, (string) file_get_contents($path));
return (string) $prompt;
}
/**
* @return array<string, mixed>
*/
public static function schema(): array
{
return (array) json_decode((string) file_get_contents(resource_path('prompts/extraction/schema.json')), true);
}
/**
* @return array{data: array{facts: list<array{field: string, value: string, evidence: string, confidence: float|int}>, change_requests: list<array{field: string, value: string, evidence: string}>, intent: string, uncertainties: list<string>}, model: string}
*/
private function call(AiAccess $access, string $model, string $system, string $text, string $effort): array
{
$schema = self::schema();
$lastError = null;
// One repetition when the answer does not fit the schema, then the message goes to the landlord.
for ($attempt = 1; $attempt <= 2; $attempt++) {
$result = $this->client->structured($access, $model, $system, $text, $schema, $effort);
$lastError = $this->violation($result['data'], $schema);
if ($lastError === null) {
return ['data' => $result['data'], 'model' => $result['model']];
}
}
throw new ExtractionFailed('Antwort passt nicht zum Schema: '.$lastError);
}
/**
* The first deviation of the answer from the schema, or null.
*
* @param array<string, mixed> $data
* @param array<string, mixed> $schema
*/
private function violation(array $data, array $schema): ?string
{
foreach ($schema['required'] as $key) {
if (! array_key_exists($key, $data)) {
return 'Feld '.$key.' fehlt';
}
}
if (! is_array($data['facts']) || ! is_array($data['change_requests']) || ! is_array($data['uncertainties']) || ! is_string($data['intent'])) {
return 'falsche Typen';
}
if (! in_array($data['intent'], $schema['properties']['intent']['enum'], true)) {
return 'unbekannte Absicht';
}
foreach (['facts', 'change_requests'] as $list) {
$item = $schema['properties'][$list]['items'];
foreach ($data[$list] as $entry) {
if (! is_array($entry) || array_diff($item['required'], array_keys($entry)) !== [] || ! in_array($entry['field'], $item['properties']['field']['enum'], true)) {
return 'ungültiger Eintrag in '.$list;
}
if (! is_string($entry['value']) || ! is_string($entry['evidence']) || ($list === 'facts' && ! is_numeric($entry['confidence']))) {
return 'falscher Typ in '.$list;
}
}
}
return null;
}
private function messageText(InboundMessage $message): string
{
return 'Subject: '.$message->subject."\n\n".mb_substr((string) $message->body, 0, 20000);
}
/**
* Values on file, masked: enough to see whether something differs, not to learn the data.
*/
private function knownFields(Booking $booking): string
{
$known = [];
foreach ([...array_keys(CaseRequirements::FIELDS), ...array_keys(CaseRequirements::OPTIONAL_FIELDS)] as $field) {
$value = (string) CaseRequirements::value($booking, $field);
if ($value === '') {
continue;
}
$known[] = $field.'='.(str_starts_with($field, 'booking.') ? $value : mb_substr($value, 0, 1).str_repeat('*', max(1, mb_strlen($value) - 2)).mb_substr($value, -1));
}
return $known === [] ? 'none' : implode('; ', $known);
}
}
@@ -0,0 +1,155 @@
<?php
namespace App\Communication\Extraction;
use App\Actions\ContributeCaseFacts;
use App\Models\Booking;
use App\Process\CaseRequirements;
use Carbon\CarbonImmutable;
/**
* The programmatic risk check of an extraction (v0.11, CH-14). The model's confidence is no calibrated probability:
* it may trigger a review, never waive one. Criticality comes from the field, the phase and the kind of deviation;
* contradictions and failed plausibility checks call for the review model regardless of the confidence, and are never
* taken over automatically. Thresholds are configured and calibrated with test messages (go-live condition).
*/
class RiskAssessment
{
/** Details whose automatic completion is harmless in every phase. */
private const ADMINISTRATIVE = ['guest.phone', 'booking.arrival_time'];
/**
* Checks every fact and marks why it may not be taken over automatically.
*
* @param array{facts: list<array{field: string, value: string, evidence: string, confidence: float|int}>, change_requests: list<array{field: string, value: string, evidence: string}>, intent: string, uncertainties: list<string>} $extraction
* @return list<array{field: string, value: string, evidence: string, confidence: float, criticality: float, problems: list<string>}>
*/
public function facts(Booking $booking, string $message, array $extraction): array
{
$checked = [];
$values = [];
foreach ($extraction['facts'] as $fact) {
$values[$fact['field']][] = mb_strtolower(trim($fact['value']));
}
foreach ($extraction['facts'] as $fact) {
$field = $fact['field'];
$value = trim($fact['value']);
$problems = [];
if (! CaseRequirements::isValid($field, $value)) {
$problems[] = 'Wert ungültig';
}
if (! $this->evidenceFound($message, $fact['evidence'])) {
$problems[] = 'Belegstelle nicht in der Nachricht';
}
if (count(array_unique($values[$field] ?? [])) > 1) {
$problems[] = 'widersprüchliche Angaben in derselben Nachricht';
}
$current = CaseRequirements::value($booking, $field);
if (CaseRequirements::isValid($field, $current) && mb_strtolower(trim((string) $current)) !== mb_strtolower($value)) {
$problems[] = 'weicht vom gespeicherten Wert ab';
}
$problems = [...$problems, ...$this->plausibility($booking, $field, $value)];
$checked[] = [
'field' => $field,
'value' => $value,
'evidence' => $fact['evidence'],
'confidence' => max(0.0, min(1.0, (float) $fact['confidence'])),
'criticality' => $this->criticality($booking, $field),
'problems' => $problems,
];
}
return $checked;
}
/**
* Whether the review model has to look at the extraction: any contradiction or failed check, any wish to change
* something in a binding phase, an uncertainty the model reported, or criticality × (1 − confidence) above the
* configured threshold.
*
* @param list<array{criticality: float, confidence: float, problems: list<string>}> $facts
* @param array{change_requests: list<mixed>, uncertainties: list<string>} $extraction
*/
public function needsReview(Booking $booking, array $facts, array $extraction): bool
{
if ($extraction['uncertainties'] !== [] || ($extraction['change_requests'] !== [] && $booking->offer_version > 0)) {
return true;
}
$threshold = (float) config('fewo.ai.escalate_above', 0.2);
foreach ($facts as $fact) {
if ($fact['problems'] !== [] || $threshold < $fact['criticality'] * (1 - $fact['confidence'])) {
return true;
}
}
return false;
}
/**
* Whether a checked fact may go to the fact intake automatically: no problem, confident enough, the detail not
* known yet, and no stay detail (those are change requests). The intake applies its own rules on top.
*
* @param array{field: string, confidence: float, problems: list<string>} $fact
*/
public function mayTakeOver(Booking $booking, array $fact): bool
{
return $fact['problems'] === []
&& $fact['confidence'] >= (float) config('fewo.ai.min_confidence', 0.85)
&& ! in_array($fact['field'], ContributeCaseFacts::STAY_FIELDS, true)
&& ! CaseRequirements::isValid($fact['field'], CaseRequirements::value($booking, $fact['field']))
&& (in_array($fact['field'], self::ADMINISTRATIVE, true) || str_starts_with($fact['field'], 'guest.'));
}
public function evidenceFound(string $message, string $evidence): bool
{
$normalise = fn (string $text): string => mb_strtolower(trim((string) preg_replace('/\s+/u', ' ', $text)));
$evidence = $normalise($evidence);
return $evidence !== '' && str_contains($normalise($message), $evidence);
}
private function criticality(Booking $booking, string $field): float
{
return match (true) {
in_array($field, self::ADMINISTRATIVE, true) => 0.3,
in_array($field, ContributeCaseFacts::STAY_FIELDS, true), $field === 'guest.email' => 1.0,
ContributeCaseFacts::isBinding($booking) => 0.8,
default => 0.6,
};
}
/**
* @return list<string>
*/
private function plausibility(Booking $booking, string $field, string $value): array
{
return match ($field) {
'booking.guests' => (int) $value > (int) $booking->property?->max_guests ? ['mehr Personen als die Wohnung fasst'] : [],
'booking.arrival', 'booking.departure' => $this->dateProblems($booking, $field, $value),
default => [],
};
}
/**
* @return list<string>
*/
private function dateProblems(Booking $booking, string $field, string $value): array
{
$date = rescue(fn () => CarbonImmutable::parse($value), null, false);
if ($date === null) {
return ['Datum nicht lesbar'];
}
if ($date->isBefore(CarbonImmutable::today())) {
return ['Datum liegt in der Vergangenheit'];
}
if ($field === 'booking.departure' && $booking->arrival !== null && ! $date->isAfter($booking->arrival)) {
return ['Abreise nicht nach der Anreise'];
}
return [];
}
}
+113
View File
@@ -0,0 +1,113 @@
<?php
namespace App\Communication;
use App\Enums\BookingStatus;
use App\Models\Booking;
use App\Models\BookingMessage;
use App\Models\InboundMessage;
use App\Models\Property;
use App\Support\Settings;
use Carbon\CarbonImmutable;
/**
* Deterministic assignment of an incoming message to a case (v0.11, CH-07, CH-13) – no scoring. A message is
* assigned only by
*
* 1. a known reply reference (In-Reply-To / References of one of our mails),
* 2. our case number together with the case's guest as sender (the number alone is no proof of identity), or
* 3. the combination of sender (the guest's e-mail), property and both dates of exactly one open case of that guest.
*
* One open case of the same sender alone is not enough; it is only shown as a hint. Everything else waits in the inbox
* for the landlord. Being assigned does not yet allow taking anything over.
*/
class MessageMatcher
{
/**
* @return array{booking: ?Booking, reason: ?string, hints: list<array{booking_id: int, reference: string, why: string}>}
*/
public function match(InboundMessage $message): array
{
$sender = mb_strtolower(trim((string) $message->from_address));
$text = $message->subject."\n".$message->body;
// Message-IDs are compared with and without angle brackets (mail servers deliver both forms).
$references = collect([$message->in_reply_to, ...((array) $message->references)])->filter()
->flatMap(fn (string $id): array => ['<'.trim($id, '<> ').'>', trim($id, '<> ')])->unique()->values()->all();
if ($references !== []) {
$replied = BookingMessage::query()->whereIn('message_id', $references)->whereNotNull('booking_id')->latest('id')->first()?->booking;
if ($replied !== null) {
return ['booking' => $replied, 'reason' => 'reply', 'hints' => []];
}
}
$hints = [];
// In test operation every answer comes from the test mailbox: there it stands for the guest of the named case.
$testSender = $message->test_mode && $sender !== '' && $sender === mb_strtolower(trim((string) Settings::tenant()?->test_recipient));
if (preg_match_all('/\b(20\d{2}-\d{4})\b/', $text, $numbers)) {
foreach (Booking::query()->whereIn('reference', array_unique($numbers[1]))->with('guest')->get() as $booking) {
if ($testSender) {
return ['booking' => $booking, 'reason' => 'reference_test_sender', 'hints' => []];
}
if ($sender !== '' && mb_strtolower((string) $booking->guest?->email) === $sender) {
return ['booking' => $booking, 'reason' => 'reference_and_sender', 'hints' => []];
}
$hints[] = ['booking_id' => $booking->id, 'reference' => $booking->reference, 'why' => 'Vorgangsnummer genannt, aber anderer Absender'];
}
}
if ($sender === '') {
return ['booking' => null, 'reason' => null, 'hints' => $hints];
}
$open = Booking::query()
->whereHas('guest', fn ($guest) => $guest->where('email', $sender))
->whereNotIn('status', [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed])
->whereDate('departure', '>=', CarbonImmutable::today())
->with('property')
->get();
$dates = $this->dates($text);
$singleProperty = Property::query()->count() === 1;
$candidates = $open->filter(fn (Booking $booking): bool => in_array($booking->arrival->toDateString(), $dates, true)
&& in_array($booking->departure->toDateString(), $dates, true)
&& ($singleProperty || mb_stripos($text, (string) $booking->property?->name) !== false));
if ($candidates->count() === 1) {
return ['booking' => $candidates->first(), 'reason' => 'sender_property_dates', 'hints' => []];
}
foreach ($open as $booking) {
$hints[] = ['booking_id' => $booking->id, 'reference' => $booking->reference, 'why' => 'offener Vorgang dieses Absenders ('.$booking->arrival->format('d.m.').'–'.$booking->departure->format('d.m.Y').')'];
}
return ['booking' => null, 'reason' => null, 'hints' => array_values(array_unique($hints, SORT_REGULAR))];
}
/**
* Dates written in the message (d.m.yyyy, d.m.yy, yyyy-mm-dd).
*
* @return list<string> Y-m-d
*/
public function dates(string $text): array
{
$dates = [];
if (preg_match_all('/\b(\d{1,2})\.\s?(\d{1,2})\.\s?(\d{4}|\d{2})\b/', $text, $german, PREG_SET_ORDER)) {
foreach ($german as [, $day, $month, $year]) {
$year = strlen($year) === 2 ? '20'.$year : $year;
if (checkdate((int) $month, (int) $day, (int) $year)) {
$dates[] = sprintf('%04d-%02d-%02d', $year, $month, $day);
}
}
}
if (preg_match_all('/\b(20\d{2})-(\d{2})-(\d{2})\b/', $text, $iso, PREG_SET_ORDER)) {
foreach ($iso as [, $year, $month, $day]) {
if (checkdate((int) $month, (int) $day, (int) $year)) {
$dates[] = sprintf('%04d-%02d-%02d', $year, $month, $day);
}
}
}
return array_values(array_unique($dates));
}
}
@@ -39,7 +39,7 @@ public function handle(TenantRunner $runner, PortalIntake $intake): int
$firstTask = (int) ChannelTask::query()->withoutGlobalScopes()->max('id');
$succeeded = $runner->each(function (Tenant $tenant) use ($intake, $apply, &$report): void {
$channels = Channel::query()->when($this->option('channel'), fn ($query, $ids) => $query->whereKey($ids))->orderBy('id')->get();
$channels = Channel::query()->portals()->when($this->option('channel'), fn ($query, $ids) => $query->whereKey($ids))->orderBy('id')->get();
foreach ($channels as $channel) {
$entries = $channel->blockedPeriods()->whereIn('source', ['channel', 'email'])->whereNull('linked_booking_id')
->where('is_representation', false)->whereDate('ends_on', '>', today())->orderBy('starts_on')->get();
@@ -0,0 +1,78 @@
<?php
namespace App\Console\Commands;
use App\Communication\Extraction\AiAccess;
use App\Communication\Extraction\ExtractionFailed;
use App\Communication\Extraction\MessageExtractor;
use App\Models\Booking;
use App\Models\InboundMessage;
use App\Models\Property;
use App\Models\Tenant;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
/**
* Measures the extraction on a set of anonymised sample messages (v0.11, M05): wrong values and missed details are
* counted separately – no system guarantees that it finds every detail, so the rate of missed ones is reported, not
* hidden. Calls the configured models (costs money); meant for calibrating prompts and thresholds before go-live.
*/
#[Signature('ai:evaluate {tenant : ID of the landlord whose own AI access is used} {--path= : JSON file with samples}')]
#[Description('Evaluate the guest message extraction against sample messages (wrong values and missed details)')]
class EvaluateExtraction extends Command
{
public function handle(MessageExtractor $extractor): int
{
$path = (string) ($this->option('path') ?: resource_path('prompts/extraction/evaluation/samples.json'));
// Bring your own key: the landlord's own access, as configured (System › KI-Anbindung).
$tenant = Tenant::query()->find((int) $this->argument('tenant'));
$service = $tenant === null ? null : AiAccess::service($tenant);
$access = $service === null ? null : AiAccess::fromService($service);
if ($access === null) {
$this->error('Für diesen Mandanten ist keine vollständige KI-Anbindung gespeichert.');
return self::FAILURE;
}
$samples = (array) json_decode((string) file_get_contents($path), true);
$property = Property::query()->withoutGlobalScopes()->first() ?? new Property(['name' => 'Ferienwohnung', 'max_guests' => 4]);
$totals = ['expected' => 0, 'found' => 0, 'missed' => 0, 'wrong' => 0, 'extra' => 0, 'changes_missed' => 0, 'failed' => 0];
foreach ($samples as $sample) {
$booking = new Booking(['arrival' => now()->addDays(14)->toDateString(), 'departure' => now()->addDays(17)->toDateString(), 'guests' => 2, 'status' => 'reserved']);
$booking->setRelation('property', $property);
$booking->setRelation('guest', null);
$message = new InboundMessage(['subject' => $sample['subject'], 'body' => $sample['body']]);
try {
$result = $extractor->extract($access, $message, $booking)['data'];
} catch (ExtractionFailed $exception) {
$totals['failed']++;
$this->warn("{$sample['id']}: {$exception->getMessage()}");
continue;
}
$found = collect($result['facts'])->mapWithKeys(fn (array $fact): array => [$fact['field'] => mb_strtolower(trim($fact['value']))])->all();
foreach ($sample['expected'] as $field => $value) {
$totals['expected']++;
match (true) {
! isset($found[$field]) => $totals['missed']++,
$found[$field] !== mb_strtolower($value) => $totals['wrong']++,
default => $totals['found']++,
};
}
$totals['extra'] += count(array_diff_key($found, $sample['expected']));
$changes = collect($result['change_requests'])->pluck('field')->all();
$totals['changes_missed'] += count(array_diff($sample['expected_changes'], $changes));
$this->line("{$sample['id']}: ".json_encode(['found' => $found, 'changes' => $changes], JSON_UNESCAPED_UNICODE));
}
$this->table(array_keys($totals), [array_values($totals)]);
$rate = $totals['expected'] > 0 ? round(100 * $totals['missed'] / $totals['expected'], 1) : 0;
$this->info("Übersehene Angaben: {$rate} % · Prompt-Version ".MessageExtractor::promptVersion());
return self::SUCCESS;
}
}
@@ -0,0 +1,41 @@
<?php
namespace App\Console\Commands;
use App\Actions\ExtractMessageFacts;
use App\Models\InboundMessage;
use App\Models\Tenant;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
use Throwable;
#[Signature('messages:extract')]
#[Description('Evaluate assigned guest and portal messages (v0.11 extraction) – a limited number per landlord and run')]
class ExtractInboundMessages extends Command
{
public function handle(ExtractMessageFacts $extract, TenantRunner $runner): int
{
$runner->each(function (Tenant $tenant) use ($extract): void {
$messages = InboundMessage::query()
->whereNotNull('booking_id')
->whereNull('extraction_status')
->whereIn('status', [InboundMessage::ASSIGNED, InboundMessage::PORTAL])
->orderBy('received_at')
->limit((int) config('fewo.ai.per_run', 10))
->get();
foreach ($messages as $message) {
try {
$this->line("{$tenant->name}: {$message->subject} → {$extract->handle($message)}");
} catch (Throwable $exception) {
report($exception);
$message->update(['extraction_status' => 'failed']);
}
}
});
return self::SUCCESS;
}
}
+22
View File
@@ -3,6 +3,7 @@
namespace App\Console\Commands;
use App\Actions\ProcessPortalMail;
use App\Actions\ReceiveInboundMessage;
use App\Channels\ChannelSyncException;
use App\Channels\Mail\MailboxReader;
use App\Enums\TenantServiceKey;
@@ -41,6 +42,27 @@ private function fetchForCurrentLandlord(MailboxReader $reader, ProcessPortalMai
return;
}
// v0.11: a dedicated mailbox is read completely; portal notifications still go through the portal path.
$mailbox = $tenant->activeMailbox();
if ($mailbox?->readsEverything()) {
try {
$mails = $reader->fetchAll();
} catch (ChannelSyncException $exception) {
$this->error("{$tenant->name}: {$exception->getMessage()}");
return;
}
foreach ($mails as $mail) {
$message = app(ReceiveInboundMessage::class)->handle($mail, $mailbox);
if ($message->wasRecentlyCreated) {
$this->info("{$tenant->name}: {$message->statusLabel()} ({$message->subject})");
}
}
$mailbox->forceFill(['last_fetched_at' => now()])->save();
return;
}
$senders = Channel::query()->active()->get()
->flatMap(fn (Channel $channel): array => $processPortalMail->senders($channel))
->unique()
@@ -0,0 +1,26 @@
<?php
namespace App\Console\Commands;
use App\Actions\RequestCaseData;
use App\Models\Tenant;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('cases:data-requests')]
#[Description('Send due reminders of data requests and hand silent ones over to the landlord – once per landlord (v0.11)')]
class ProcessDataRequests extends Command
{
public function handle(RequestCaseData $requests, TenantRunner $runner): int
{
$runner->each(function (Tenant $tenant) use ($requests): void {
$count = $requests->remindDue();
$this->info("{$tenant->name}: {$count} Erinnerung(en) gesendet.");
});
return self::SUCCESS;
}
}
@@ -0,0 +1,58 @@
<?php
namespace App\Console\Commands;
use App\Actions\RecordPayment;
use App\Enums\BookingStatus;
use App\Models\Booking;
use App\Models\Tenant;
use App\Process\CaseLog;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('cases:recheck-payment-status
{--apply : Wirklich korrigieren (ohne: nur Vorschau)}')]
#[Description('Zahlungsstatus bestehender Vorgänge nach der neuen Regel prüfen: nur Geld des Gastes auf unserem Konto zählt als „Anzahlung erhalten“/„Bezahlt“, nicht „laut Portal bezahlt“ (Vorschau, Korrektur nur mit --apply und mit Eintrag im Verlauf)')]
class RecheckPaymentStatus extends Command
{
public function handle(TenantRunner $runner): int
{
$apply = (bool) $this->option('apply');
$rows = [];
$succeeded = $runner->each(function (Tenant $tenant) use ($apply, &$rows): void {
$cases = Booking::query()->with(['payments', 'property', 'importChannel', 'originChannel'])
->whereIn('status', [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid])->get();
foreach ($cases as $booking) {
$target = RecordPayment::statusFor($booking);
if ($target === null || $target === $booking->status) {
continue;
}
$rows[] = [$tenant->name, $booking->reference, $booking->status->getLabel(), $target->getLabel(), $apply ? 'korrigiert' : 'Vorschau'];
if ($apply) {
CaseLog::context(fn () => $booking->update(['status' => $target]), actor: CaseLog::SYSTEM, reason: 'Zahlungsstatus nach neuer Regel: „laut Portal bezahlt“ ist kein Eingang auf unserem Konto (cases:recheck-payment-status).');
}
}
});
if ($rows === []) {
$this->info('Kein Vorgang mit abweichendem Zahlungsstatus.');
} else {
$this->table(['Vermieter', 'Vorgang', 'bisher', 'nach neuer Regel', 'Ergebnis'], $rows);
if (! $apply) {
$this->comment('Nur Vorschau. Mit --apply werden die Status korrigiert und im Verlauf vermerkt.');
}
}
if ($succeeded < $runner->tenants()->count()) {
$this->error('Für mindestens einen Vermieter ist die Prüfung fehlgeschlagen (siehe Log).');
return self::FAILURE;
}
return self::SUCCESS;
}
}
@@ -25,10 +25,13 @@ public function handle(AutoOffer $autoOffer, TenantRunner $runner): int
$pending = Booking::query()
->where('status', BookingStatus::Reserved)
->where('offer_version', 0)
->where('hold_expires_at', '>', now())
->where('information_version', 0)
// Held requests while their hold runs; requests without a hold (information, package 7) for two weeks.
->where(fn ($query) => $query->where('hold_expires_at', '>', now())->orWhere(fn ($open) => $open->whereNull('hold_expires_at')->where('created_at', '>', now()->subDays(14))))
->where(fn ($query) => $query->whereNull('intake')->orWhere('intake', 'inquiry'))
->with(['property', 'guest', 'importChannel', 'originChannel'])
->get()
->filter(fn (Booking $booking): bool => $autoOffer->applies($booking) && $booking->process()->preReservation());
->filter(fn (Booking $booking): bool => $autoOffer->applies($booking) && ($booking->isHoldActive() || ! $booking->process()->preReservation()));
$sent = 0;
foreach ($pending as $booking) {
+34 -10
View File
@@ -2,6 +2,7 @@
namespace App\Documents;
use App\Actions\SendInformation;
use App\Actions\SendOffer;
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
@@ -16,6 +17,7 @@
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\CaseActivities;
use App\Process\CaseRequirements;
use App\Process\ProcessProfile;
use App\Process\ProcessSettings;
use App\Support\Money;
@@ -55,11 +57,12 @@ public function compose(Booking $booking, ?DocumentKind $kind = null, array $cha
$draft = clone $booking;
$draft->setRelation('guest', $booking->guest !== null ? (clone $booking->guest)->fill(self::guestChanges($changes)) : null);
if ($kind === DocumentKind::Offer) {
$findings = [...$findings, ...$this->prepareOffer($booking, $draft, $changes)];
$quoted = in_array($kind, [DocumentKind::Offer, DocumentKind::Information], true);
if ($quoted) {
$findings = [...$findings, ...$this->prepareOffer($booking, $draft, $changes, $kind)];
}
$frozen = $kind !== DocumentKind::Offer && ($booking->contract_path !== null || ($booking->offer_version > 0 && is_array($booking->offer_terms)));
$frozen = ! $quoted && ($booking->contract_path !== null || ($booking->offer_version > 0 && is_array($booking->offer_terms)));
$explicitTemplate = ! $frozen && filled($changes['contract_template_id'] ?? null);
$template = match (true) {
$kind === DocumentKind::StayConfirmation => null,
@@ -99,17 +102,19 @@ public function compose(Booking $booking, ?DocumentKind $kind = null, array $cha
}
/**
* Applies the offer adjustments to the copy and calculates its price exactly as {@see SendOffer} will.
* Applies the offer adjustments to the copy and calculates its price exactly as {@see SendOffer} (and the information
* of a request without a hold, {@see SendInformation}) will.
*
* @param array<string, mixed> $changes
* @return list<DocumentFinding>
*/
private function prepareOffer(Booking $booking, Booking $draft, array $changes): array
private function prepareOffer(Booking $booking, Booking $draft, array $changes, DocumentKind $kind = DocumentKind::Offer): array
{
$findings = [];
$information = $kind === DocumentKind::Information;
if (! in_array($booking->status, [BookingStatus::Reserved, BookingStatus::OfferSent, BookingStatus::Expired], true)) {
$findings[] = DocumentFinding::blocker('Für diesen Vorgang ist kein Angebot mehr möglich ('.$booking->status->getLabel().').');
if (! in_array($booking->status, $information ? [BookingStatus::Reserved, BookingStatus::Expired] : [BookingStatus::Reserved, BookingStatus::OfferSent, BookingStatus::Expired], true)) {
$findings[] = DocumentFinding::blocker('Für diesen Vorgang ist '.($information ? 'keine Auskunft' : 'kein Angebot').' mehr möglich ('.$booking->status->getLabel().').');
}
try {
@@ -141,6 +146,20 @@ private function prepareOffer(Booking $booking, Booking $draft, array $changes):
$findings[] = DocumentFinding::blocker('Bitte Anreise, Abreise und Personen angeben.');
}
if ($information) {
$draft->forceFill([
'information_valid_until' => filled($changes['valid_until'] ?? null) ? CarbonImmutable::parse($changes['valid_until']) : now()->addHours($booking->process()->holdHours()),
'information_version' => $booking->information_version + 1,
'offer_message' => $changes['offer_message'] ?? $booking->offer_message,
]);
$findings[] = DocumentFinding::info('Unverbindliche Auskunft: Der Zeitraum wird nicht reserviert, und der Gast kann nicht direkt annehmen. Fragt er die Buchung an, wird erneut geprüft.');
if ($booking->information_version > 0) {
$findings[] = DocumentFinding::info('Ersetzt Auskunft Version '.$booking->information_version.'; deren Link wird ungültig.');
}
return $findings;
}
$draft->forceFill([
'hold_expires_at' => filled($changes['valid_until'] ?? null) ? CarbonImmutable::parse($changes['valid_until']) : now()->addHours($booking->process()->holdHours()),
'offer_version' => $booking->offer_version + 1,
@@ -149,7 +168,7 @@ private function prepareOffer(Booking $booking, Booking $draft, array $changes):
]);
if (! $booking->process()->preReservation()) {
$findings[] = DocumentFinding::confirm('Nach Ihrer Einstellung reservieren Anfragen den Zeitraum nicht. Ein Angebot mit Annahmelink reserviert ihn trotzdem bis '.$draft->hold_expires_at->format('d.m.Y, H:i').' Uhr, und der Gast kann bis dahin verbindlich annehmen. Eine Auskunft ohne Reservierung gibt es erst in einem späteren Ausbauschritt.', DocumentFinding::HOLD_ZERO);
$findings[] = DocumentFinding::confirm('Nach Ihrer Einstellung reservieren Anfragen den Zeitraum nicht; vorgesehen ist eine unverbindliche Auskunft. Ein Angebot mit Annahmelink reserviert den Zeitraum für diesen Vorgang trotzdem bis '.$draft->hold_expires_at->format('d.m.Y, H:i').' Uhr, und der Gast kann bis dahin verbindlich annehmen.', DocumentFinding::HOLD_ZERO);
}
if ($booking->offer_version > 0) {
$findings[] = DocumentFinding::info('Ersetzt Angebot Version '.$booking->offer_version.'; dessen Link wird ungültig.');
@@ -176,7 +195,12 @@ private function commonFindings(Booking $booking, Booking $draft, DocumentKind $
} elseif (blank($draft->guest->email)) {
$findings[] = DocumentFinding::blocker('Die E-Mail-Adresse des Gastes fehlt.');
}
if ($kind !== DocumentKind::Offer && $booking->total === null) {
// G2a (v0.11, E-032): an own binding offer needs the contracting party's name, e-mail, full address with country,
// the number of guests and the dates – a hard blocker, also by hand. The information "unter Vorbehalt" does not (B3).
if ($kind === DocumentKind::Offer && $draft->guest !== null && ($missing = CaseRequirements::blocker($draft, CaseRequirements::OFFER)) !== null) {
$findings[] = DocumentFinding::blocker($missing);
}
if (! in_array($kind, [DocumentKind::Offer, DocumentKind::Information], true) && $booking->total === null) {
$findings[] = DocumentFinding::blocker($booking->intake === IntakeKind::Booking ? 'Der Gesamtpreis (laut Portal) fehlt.' : 'Der Preis fehlt.');
}
if ($booking->confirmation_sent_at !== null && $kind !== DocumentKind::Offer) {
@@ -249,7 +273,7 @@ private function priceSource(Booking $booking, Booking $draft, DocumentKind $kin
return match (true) {
$draft->total === null => 'noch nicht bekannt',
($draft->quote['source'] ?? null) === 'portal' => 'laut '.($booking->processChannel()?->name ?? 'Portal').' übernommen, nicht neu berechnet',
$kind === DocumentKind::Offer => 'aus Ihren Preisen berechnet',
in_array($kind, [DocumentKind::Offer, DocumentKind::Information], true) => 'aus Ihren Preisen berechnet',
$booking->accepted_at !== null => 'wie im angenommenen Angebot',
default => 'aus Ihren Preisen berechnet',
};
+2
View File
@@ -7,6 +7,7 @@
use App\Filament\Pages\PricesAndOffers;
use App\Filament\Resources\BlockedPeriods\BlockedPeriodResource;
use App\Filament\Resources\Bookings\BookingResource;
use App\Filament\Resources\Channels\ChannelResource;
use App\Filament\Resources\Guests\GuestResource;
use Filament\Support\Contracts\HasDescription;
use Filament\Support\Contracts\HasLabel;
@@ -32,6 +33,7 @@ enum AdminMode: string implements HasDescription, HasLabel
GuestResource::class,
BlockedPeriodResource::class,
PricesAndOffers::class,
ChannelResource::class,
];
public function getLabel(): string
+57 -2
View File
@@ -8,6 +8,10 @@
/**
* What the landlord has to do about a booking. Payment tasks are created by the daily run; nothing is
* sent to the guest until the landlord has checked the payment and chooses to send the mail.
*
* Package 9 sorts every task into what it holds up: tasks of the stay ({@see self::blocksStay()}) keep the stay from
* being closed, commercial tasks ({@see self::isCommercial()}) keep the case from being settled, follow-ups hold up
* neither and simply stay on the case until they are done.
*/
enum BookingTaskKind: string implements HasLabel
{
@@ -20,6 +24,17 @@ enum BookingTaskKind: string implements HasLabel
case PortalCancellationReported = 'portal_cancel_reported';
case PortalChangeReported = 'portal_change_reported';
case RefundCheck = 'refund_check';
case BookingWish = 'booking_wish';
case ArrivalDetails = 'arrival_details';
case Service = 'service';
case Issue = 'issue';
case FollowUp = 'follow_up';
case PayoutCheck = 'payout_check';
case OpenClaim = 'open_claim';
case FactConflict = 'fact_conflict';
case ChangeRequest = 'change_request';
case GuestUnresponsive = 'guest_unresponsive';
case InboundReview = 'inbound_review';
public function getLabel(): string
{
@@ -33,12 +48,52 @@ public function getLabel(): string
self::PortalCancellationReported => 'Das Portal meldet eine Stornierung – bitte prüfen',
self::PortalChangeReported => 'Das Portal meldet eine Änderung – bitte prüfen',
self::RefundCheck => 'Erstattung an den Gast prüfen',
self::BookingWish => 'Buchungswunsch bestätigen?',
self::ArrivalDetails => 'Anreisedaten beim Gast erfragen',
self::Service => 'Leistung vorbereiten',
self::Issue => 'Abweichung oder Problem klären',
self::FollowUp => 'Folgeaufgabe',
self::PayoutCheck => 'Auszahlung des Portals prüfen',
self::OpenClaim => 'Offenen Betrag nach der Abreise klären',
self::FactConflict => 'Abweichende Angabe des Gastes prüfen',
self::ChangeRequest => 'Änderungswunsch des Gastes prüfen',
self::GuestUnresponsive => 'Fehlende Angaben selbst beim Gast nachfragen',
self::InboundReview => 'Antwort des Gastes prüfen',
};
}
/**
* Whether this is a payment reminder task (created by the daily run, settled by a payment or a reminder mail).
*/
public function isPayment(): bool
{
return ! in_array($this, [self::CancellationRequest, self::CancellationFee, self::PortalCancellation, self::PortalCancellationReported, self::PortalChangeReported, self::RefundCheck], true);
return in_array($this, [self::DepositReminder, self::BalanceRequest, self::BalanceReminder], true);
}
/**
* Whether an open task of this kind keeps the stay from being closed (it belongs to the stay itself).
*/
public function blocksStay(): bool
{
return in_array($this, [self::Service, self::Issue, self::PortalChangeReported], true);
}
/**
* Whether an open task of this kind keeps the case from being commercially settled.
*/
public function isCommercial(): bool
{
return $this->isPayment() || in_array($this, [self::CancellationFee, self::RefundCheck, self::PayoutCheck, self::OpenClaim], true);
}
/**
* Kinds the landlord adds by hand on a case (several per case, each with its own title).
*
* @return list<self>
*/
public static function manual(): array
{
return [self::Service, self::Issue, self::FollowUp];
}
/**
@@ -52,7 +107,7 @@ public function reminder(): ?array
self::DepositReminder => [PaymentReminder::DEPOSIT_OVERDUE, 'deposit_reminded_at'],
self::BalanceRequest => [PaymentReminder::BALANCE_REQUEST, 'balance_requested_at'],
self::BalanceReminder => [PaymentReminder::BALANCE_OVERDUE, 'balance_reminded_at'],
self::CancellationRequest, self::CancellationFee, self::PortalCancellation, self::PortalCancellationReported, self::PortalChangeReported, self::RefundCheck => null,
default => null,
};
}
}
+25
View File
@@ -0,0 +1,25 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* How missing details are requested from the guest (v0.11, CH §1.6) – independent of whether offers go out
* automatically.
*/
enum DataRequestMode: string implements HasLabel
{
case Automatic = 'automatic';
case Approval = 'approval';
case Manual = 'manual';
public function getLabel(): string
{
return match ($this) {
self::Automatic => 'Automatisch beim Gast nachfragen',
self::Approval => 'Rückfrage vorbereiten, Sie geben den Versand frei',
self::Manual => 'Sie fragen selbst nach (Aufgabe mit Textvorschlag)',
};
}
}
+9 -4
View File
@@ -9,8 +9,8 @@
* The kinds of documents a case can produce (UMSETZUNGSPLAN_v0.10 §5.4). Which one a case needs follows from its case
* type, never from a choice of the landlord: a request gets a binding offer, a booking we made ourselves gets the
* confirmation with the rental contract, a booking that is already binding on a portal gets the booking documentation
* without an acceptance link (E-004). Information "unter Vorbehalt" (package 7) and the stay confirmation of A6
* (package 6) are prepared as working drafts but cannot be sent yet.
* without an acceptance link (E-004), a request without a hold gets the information "unter Vorbehalt" with the link to
* ask for the booking (package 7, E-026).
*/
enum DocumentKind: string implements HasLabel
{
@@ -20,6 +20,7 @@ enum DocumentKind: string implements HasLabel
case ExternalRecord = 'external_record';
case StayConfirmation = 'stay_confirmation';
case Internal = 'internal';
case DataRequest = 'data_request';
public function getLabel(): string
{
@@ -30,6 +31,7 @@ public function getLabel(): string
self::ExternalRecord => 'Buchungsunterlagen (beim Portal gebucht)',
self::StayConfirmation => 'Aufenthaltsbestätigung (privat)',
self::Internal => 'Nur intern, kein Dokument an Gäste',
self::DataRequest => 'Rückfrage nach fehlenden Angaben',
};
}
@@ -40,11 +42,12 @@ public function description(): string
{
return match ($this) {
self::Offer => 'Für Anfragen: Preis, Vertragsentwurf und ein Link, mit dem der Gast verbindlich annimmt.',
self::Information => 'Für Anfragen ohne Reservierung: Preis und Verfügbarkeit ohne Zusage; der Gast kann die Buchung anfragen. Folgt mit Paket 7.',
self::Information => 'Für Anfragen ohne Reservierung: Preis und Verfügbarkeit zum Zeitpunkt der Prüfung, ohne Reservierung und ohne Zusage. Der Gast kann daraus die Buchung anfragen; verbindlich wird sie erst mit Ihrer (oder der automatischen) Bestätigung nach erneuter Prüfung.',
self::Confirmation => 'Nach der Annahme eines Angebots oder einer direkt vereinbarten Buchung: Bestätigung mit dem Mietvertrag.',
self::ExternalRecord => 'Für Buchungen, die beim Portal bereits verbindlich sind: Buchungsdaten und – falls hinterlegt – Ihre Vorlage, ohne erneute Annahme durch den Gast.',
self::StayConfirmation => 'Für private Überlassungen (Familie, Freunde): Bestätigung des Aufenthalts ohne Mietvertrag, nur auf Wunsch.',
self::Internal => 'Eigennutzung und Wartung: kein Dokument an Gäste.',
self::DataRequest => 'E-Mail an den Gast mit der Bitte um fehlende Angaben (Anschrift, Personenzahl …) und einem persönlichen Link zum Ergänzen, dazu Erinnerungen und gezielte Folgefragen. Sie nennt nur eine tatsächlich bestehende vorläufige Reservierung. Im Testbetrieb gehen die Texte auch ohne Freigabe hinaus (nur an die Testadresse).',
};
}
@@ -59,6 +62,7 @@ public static function forCase(Booking $booking): ?self
$booking->intake === IntakeKind::Internal => $booking->guest_id !== null ? self::StayConfirmation : self::Internal,
$booking->caseType()->isExternallyBinding() => $profile->documents() === Responsibility::Portal ? null : self::ExternalRecord,
$booking->isBinding() => $profile->documents() === Responsibility::Portal ? null : self::Confirmation,
! $profile->preReservation() => self::Information,
default => self::Offer,
};
}
@@ -84,7 +88,7 @@ public function containsContract(): bool
*/
public function isAvailable(): bool
{
return in_array($this, [self::Offer, self::Confirmation, self::ExternalRecord, self::StayConfirmation], true);
return in_array($this, [self::Offer, self::Information, self::Confirmation, self::ExternalRecord, self::StayConfirmation, self::DataRequest], true);
}
/**
@@ -116,6 +120,7 @@ public function fileName(): string
self::ExternalRecord => 'Buchungsunterlagen',
self::StayConfirmation => 'Aufenthaltsbestaetigung',
self::Internal => 'Intern',
self::DataRequest => 'Rueckfrage',
};
}
}
+38
View File
@@ -0,0 +1,38 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* Where a detail of a case came from (v0.11 common fact intake, S5).
*/
enum FactSource: string implements HasLabel
{
case WebsiteForm = 'website_form';
case GuestLink = 'guest_link';
case Email = 'email';
case PortalMail = 'portal_mail';
case Extraction = 'llm';
case Landlord = 'landlord';
public function getLabel(): string
{
return match ($this) {
self::WebsiteForm => 'Anfrageformular der Webseite',
self::GuestLink => 'Gast über den Ergänzungslink',
self::Email => 'E-Mail des Gastes',
self::PortalMail => 'Portal-Mail',
self::Extraction => 'aus einer Nachricht erkannt (KI)',
self::Landlord => 'von Ihnen eingetragen',
};
}
/**
* The landlord's own entry is authoritative; every other source only completes or is put to the landlord.
*/
public function isAuthoritative(): bool
{
return $this === self::Landlord;
}
}
+3 -1
View File
@@ -15,6 +15,7 @@ enum InboxMessageKind: string implements HasColor, HasLabel
case OfferMailFailed = 'offer_mail_failed';
case OfferRejected = 'offer_rejected';
case SyncFailed = 'sync_failed';
case AiAccessRejected = 'ai_access_rejected';
public function getLabel(): string
{
@@ -24,6 +25,7 @@ public function getLabel(): string
self::OfferMailFailed => 'Angebot nicht zugestellt',
self::OfferRejected => 'Annahme abgewiesen',
self::SyncFailed => 'Kalenderabgleich gestört',
self::AiAccessRejected => 'KI-Anbindung abgelehnt',
};
}
@@ -31,7 +33,7 @@ public function getColor(): string
{
return match ($this) {
self::ChannelConflict, self::SyncFailed => 'danger',
self::ConfirmationFailed, self::OfferMailFailed, self::OfferRejected => 'warning',
self::ConfirmationFailed, self::OfferMailFailed, self::OfferRejected, self::AiAccessRejected => 'warning',
};
}
}
+40 -3
View File
@@ -17,6 +17,14 @@ enum ProcessSetting: string
case GuestMessages = 'guest_messages';
case ArrivalInfoDaysBefore = 'arrival_info_days_before';
case ContractTemplate = 'contract_template_id';
case ClarificationHoldAutoMinutes = 'clarification_hold_auto_minutes';
case ClarificationHoldManualMinutes = 'clarification_hold_manual_minutes';
case DataRequest = 'data_request_mode';
case DataRequestRemindersMax = 'data_request_reminders_max';
case DataRequestFollowupsMax = 'data_request_followups_max';
case DataRequestReminderHours = 'data_request_reminder_hours';
case GuestLinkValidDays = 'guest_link_valid_days';
case FormRequiresAddress = 'form_requires_address';
/**
* Built-in default (the behaviour before any landlord setting existed).
@@ -30,6 +38,14 @@ public function default(): string|int|bool|null
self::Documents, self::Payments, self::GuestMessages => Responsibility::Landlord->value,
self::ArrivalInfoDaysBefore => 3,
self::ContractTemplate => null,
self::ClarificationHoldAutoMinutes => 15,
self::ClarificationHoldManualMinutes => 180,
self::DataRequest => DataRequestMode::Approval->value,
self::DataRequestRemindersMax => 2,
self::DataRequestFollowupsMax => 2,
self::DataRequestReminderHours => 24,
self::GuestLinkValidDays => 14,
self::FormRequiresAddress => false,
};
}
@@ -41,12 +57,20 @@ public function question(): string
return match ($this) {
self::Processing => 'Wie sollen neue Vorgänge bearbeitet werden?',
self::PreReservation => 'Soll eine Anfrage den Zeitraum im Kalender reservieren?',
self::HoldHours => 'Wie lange gilt ein Angebot (und bleibt der Zeitraum reserviert)?',
self::HoldHours => 'Wie lange gilt ein Angebot bzw. eine unverbindliche Auskunft (mit Reservierung: so lange bleibt der Zeitraum reserviert)?',
self::Documents => 'Wer schickt dem Gast Vertrag bzw. Buchungsunterlagen?',
self::Payments => 'Wer kümmert sich um die Zahlungen des Gastes?',
self::GuestMessages => 'Wer schickt dem Gast Anreise-Informationen und die Bitte um eine Bewertung?',
self::ArrivalInfoDaysBefore => 'Wann gehen die Anreise-Informationen an den Gast?',
self::ContractTemplate => 'Welche Vertragsvorlage wird verwendet?',
self::ClarificationHoldAutoMinutes => 'Wie lange wird der Zeitraum einer unvollständigen Anfrage vorläufig reserviert, wenn automatisch nachgefragt wird (0 = gar nicht)?',
self::ClarificationHoldManualMinutes => 'Wie lange wird der Zeitraum einer unvollständigen Anfrage vorläufig reserviert, wenn Sie die Rückfrage freigeben oder selbst nachfragen (0 = gar nicht)?',
self::DataRequest => 'Wie wird nach fehlenden Angaben gefragt?',
self::DataRequestRemindersMax => 'Wie oft wird höchstens erinnert, wenn der Gast nicht antwortet?',
self::DataRequestFollowupsMax => 'Wie viele gezielte Folgefragen gehen höchstens hinaus, wenn eine Antwort unvollständig ist?',
self::DataRequestReminderHours => 'Nach wie vielen Stunden ohne Antwort wird erinnert?',
self::GuestLinkValidDays => 'Wie lange gilt der Link, über den der Gast Angaben ergänzt?',
self::FormRequiresAddress => 'Muss die vollständige Anschrift schon im Anfrageformular der Webseite angegeben werden?',
};
}
@@ -61,7 +85,9 @@ public function channelIntakes(): array
self::Processing, self::Payments, self::GuestMessages, self::ContractTemplate => [IntakeKind::Inquiry, IntakeKind::Booking],
self::PreReservation, self::HoldHours => [IntakeKind::Inquiry],
self::Documents => [IntakeKind::Booking],
self::ArrivalInfoDaysBefore => [],
self::ArrivalInfoDaysBefore, self::GuestLinkValidDays => [],
self::ClarificationHoldAutoMinutes, self::ClarificationHoldManualMinutes, self::FormRequiresAddress => [IntakeKind::Inquiry],
self::DataRequest, self::DataRequestRemindersMax, self::DataRequestFollowupsMax, self::DataRequestReminderHours => [IntakeKind::Inquiry, IntakeKind::Booking],
};
}
@@ -85,8 +111,12 @@ public function normalize(mixed $value): string|int|bool|null
return match ($this) {
self::Processing => ($value instanceof ProcessingMode ? $value : ProcessingMode::tryFrom((string) $value))?->value,
self::Documents, self::Payments, self::GuestMessages => ($value instanceof Responsibility ? $value : Responsibility::tryFrom((string) $value))?->value,
self::PreReservation => filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE),
self::PreReservation, self::FormRequiresAddress => is_bool($value) ? $value : filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE),
self::HoldHours, self::ArrivalInfoDaysBefore, self::ContractTemplate => is_numeric($value) ? (int) $value : null,
self::DataRequest => ($value instanceof DataRequestMode ? $value : DataRequestMode::tryFrom((string) $value))?->value,
// 0 is a value of its own: no clarification hold, no reminder, no follow-up question.
self::ClarificationHoldAutoMinutes, self::ClarificationHoldManualMinutes, self::DataRequestRemindersMax, self::DataRequestFollowupsMax => is_numeric($value) ? max(0, (int) $value) : null,
self::DataRequestReminderHours, self::GuestLinkValidDays => is_numeric($value) ? max(1, (int) $value) : null,
};
}
@@ -102,6 +132,13 @@ public function describe(string|int|bool|null $value): string
self::HoldHours => $value.' Stunden',
self::ArrivalInfoDaysBefore => $value.' Tage vor Anreise',
self::ContractTemplate => $value === null ? 'Texte der Webseite' : 'Vorlage Nr. '.$value,
self::ClarificationHoldAutoMinutes, self::ClarificationHoldManualMinutes => (int) $value === 0 ? 'keine vorläufige Reservierung' : $value.' Minuten',
self::DataRequest => DataRequestMode::tryFrom((string) $value)?->getLabel() ?? '–',
self::DataRequestRemindersMax => (int) $value === 0 ? 'keine Erinnerung' : 'höchstens '.$value.' Erinnerung'.((int) $value === 1 ? '' : 'en'),
self::DataRequestFollowupsMax => (int) $value === 0 ? 'keine Folgefrage' : 'höchstens '.$value.' Folgefrage'.((int) $value === 1 ? '' : 'n'),
self::DataRequestReminderHours => 'nach '.$value.' Stunden',
self::GuestLinkValidDays => $value.' Tage',
self::FormRequiresAddress => $value ? 'ja, Pflichtangabe' : 'nein, kann nachgefragt werden',
};
}
}
+7 -5
View File
@@ -31,7 +31,8 @@ public function description(): string
return match ($this) {
self::PortalSync => 'Belegungen der Portale über iCal einlesen und den eigenen Kalender als Feed anbieten.',
self::PortalMail => 'Buchungsmails der Portale aus dem Postfach lesen und Termine sofort sperren.',
self::AiOffers, self::AiMarketing, self::AiGuestMail => 'Noch nicht gebaut.',
self::AiGuestMail => 'Antworten und Nachrichten der Gäste auswerten: erkannte Angaben (Anschrift, Telefon …) werden vorgeschlagen und nur nach festen Regeln übernommen; nichts Verbindliches entscheidet die KI.',
self::AiOffers, self::AiMarketing => 'Noch nicht gebaut.',
};
}
@@ -41,8 +42,8 @@ public function description(): string
public function isWired(): bool
{
return match ($this) {
self::PortalSync, self::PortalMail => true,
self::AiOffers, self::AiMarketing, self::AiGuestMail => false,
self::PortalSync, self::PortalMail, self::AiGuestMail => true,
self::AiOffers, self::AiMarketing => false,
};
}
@@ -52,11 +53,12 @@ public function isWired(): bool
*/
public function enabledByDefault(): bool
{
return $this->isWired();
// The AI service sends guests' messages to an external provider: only after the operator switched it on.
return $this->isWired() && $this !== self::AiGuestMail;
}
/**
* Whether the landlord's own API key is of any use. Nothing calls out yet, so no service has one.
* Whether the landlord's own API key is of any use (the guest communication extraction calls out).
*/
public function usesApiKey(): bool
{
+23
View File
@@ -0,0 +1,23 @@
<?php
namespace App\Events;
use App\Enums\FactSource;
use App\Models\Booking;
use App\Process\FactContribution;
use Illuminate\Foundation\Events\Dispatchable;
/**
* Details arrived for a case and went through the common fact intake (after the commit). The data request of the
* case listens to stop reminders or to plan a follow-up question (CH-17).
*/
class CaseFactsContributed
{
use Dispatchable;
public function __construct(
public readonly Booking $booking,
public readonly FactContribution $contribution,
public readonly FactSource $source,
) {}
}
@@ -9,6 +9,7 @@
use App\Enums\DocumentKind;
use App\Mail\BookingConfirmed;
use App\Mail\BookingDocumentation;
use App\Mail\InformationSent;
use App\Mail\OfferMade;
use App\Mail\StayConfirmed;
use App\Models\Booking;
@@ -86,6 +87,7 @@ private static function mailPreview(DocumentComposition $composition): string
try {
return match ($composition->kind) {
DocumentKind::Offer => (new OfferMade($draft, '#'))->render(),
DocumentKind::Information => (new InformationSent($draft, '#'))->render(),
DocumentKind::ExternalRecord => (new BookingDocumentation($draft))->render(),
DocumentKind::StayConfirmation => (new StayConfirmed($draft))->render(),
default => (new BookingConfirmed($draft))->render(),
@@ -100,7 +102,7 @@ private static function mailPreview(DocumentComposition $composition): string
private static function documentPreview(DocumentComposition $composition): string
{
try {
[$view, $data] = app(RentalContract::class)->view($composition->draft, $composition->kind, draft: $composition->kind === DocumentKind::Offer);
[$view, $data] = app(RentalContract::class)->view($composition->draft, $composition->kind, draft: in_array($composition->kind, [DocumentKind::Offer, DocumentKind::Information], true));
return view($view, $data)->render();
} catch (Throwable $exception) {
+10 -1
View File
@@ -2,6 +2,7 @@
namespace App\Filament\Forms;
use App\Enums\DataRequestMode;
use App\Enums\ProcessingMode;
use App\Enums\ProcessSetting;
use App\Enums\Responsibility;
@@ -34,13 +35,21 @@ public static function field(string $name, ProcessSetting $setting, string $inhe
return (match ($setting) {
ProcessSetting::Processing => Select::make($name)->options(ProcessingMode::class)->placeholder($placeholder)
->helperText('Automatisch: Das System sendet Angebote bzw. Unterlagen selbst, sobald alle Angaben da sind. Sonst bereitet es alles vor und Sie geben frei.'),
ProcessSetting::PreReservation => Select::make($name)->options(['1' => 'Ja – der Zeitraum ist bis zum Ablauf des Angebots reserviert', '0' => 'Nein – eine Anfrage reserviert nichts'])->placeholder($placeholder),
ProcessSetting::PreReservation => Select::make($name)->options(['1' => 'Ja – der Zeitraum ist bis zum Ablauf des Angebots reserviert', '0' => 'Nein – der Gast erhält eine unverbindliche Auskunft und kann daraus die Buchung anfragen (erneute Prüfung vor der Bestätigung)'])->placeholder($placeholder),
ProcessSetting::HoldHours => TextInput::make($name)->integer()->minValue(1)->maxValue(720)->suffix('Stunden')->placeholder($placeholder),
ProcessSetting::Documents, ProcessSetting::Payments, ProcessSetting::GuestMessages => Select::make($name)->options([Responsibility::Landlord->value => Responsibility::Landlord->getLabel(), Responsibility::Portal->value => Responsibility::Portal->getLabel()])->placeholder($placeholder),
ProcessSetting::ArrivalInfoDaysBefore => TextInput::make($name)->integer()->minValue(1)->maxValue(14)->suffix('Tage vor Anreise')->placeholder($placeholder),
ProcessSetting::ContractTemplate => Select::make($name)
->options(fn (): array => ContractTemplate::query()->orderBy('name')->orderBy('version')->get()->mapWithKeys(fn (ContractTemplate $template): array => [$template->id => $template->label()])->all())
->placeholder($placeholder),
ProcessSetting::ClarificationHoldAutoMinutes, ProcessSetting::ClarificationHoldManualMinutes => TextInput::make($name)->integer()->minValue(0)->maxValue(1440)->suffix('Minuten')->placeholder($placeholder)
->helperText('Nur für Anfragen, denen noch Angaben für ein Angebot fehlen, und nur wenn der Zeitraum frei ist. Endet von selbst und wird durch Rückfragen nicht verlängert. Die Reservierung eines Angebots bleibt davon unberührt.'),
ProcessSetting::DataRequest => Select::make($name)->options(DataRequestMode::class)->placeholder($placeholder)
->helperText('Unabhängig davon, ob Angebote automatisch hinausgehen.'),
ProcessSetting::DataRequestRemindersMax, ProcessSetting::DataRequestFollowupsMax => TextInput::make($name)->integer()->minValue(0)->maxValue(5)->placeholder($placeholder),
ProcessSetting::DataRequestReminderHours => TextInput::make($name)->integer()->minValue(1)->maxValue(336)->suffix('Stunden')->placeholder($placeholder),
ProcessSetting::GuestLinkValidDays => TextInput::make($name)->integer()->minValue(1)->maxValue(60)->suffix('Tage')->placeholder($placeholder),
ProcessSetting::FormRequiresAddress => Select::make($name)->options(['1' => 'Ja – ohne vollständige Anschrift kann nicht angefragt werden', '0' => 'Nein – fehlt sie, wird beim Gast nachgefragt'])->placeholder($placeholder),
})->label($setting->question());
}
+196
View File
@@ -0,0 +1,196 @@
<?php
namespace App\Filament\Pages;
use App\Communication\Extraction\AiAccess;
use App\Communication\Extraction\AiProvider;
use App\Communication\Extraction\ExtractionFailed;
use App\Communication\Extraction\LlmClient;
use App\Enums\TenantServiceKey;
use App\Enums\UserRole;
use App\Filament\Concerns\FollowsAdminMode;
use App\Models\Tenant;
use App\Models\TenantService;
use App\Support\Settings;
use App\Tenancy\TenantFeatures;
use BackedEnum;
use Filament\Actions\Action;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Pages\Page;
use Filament\Schemas\Components\Actions;
use Filament\Schemas\Components\EmbeddedSchema;
use Filament\Schemas\Components\Form;
use Filament\Schemas\Components\Section;
use Filament\Schemas\Components\Text;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Schema;
use Filament\Support\Icons\Heroicon;
use UnitEnum;
/**
* "KI-Anbindung" (v0.11, bring your own key): the landlord connects his own AI access for the evaluation of guest
* messages – provider (Anthropic or OpenRouter), key and the two models. The key is stored encrypted and never shown
* again; an empty field keeps it. A check sends a tiny test request to both models. The page only exists when the
* operator switched the service on for this landlord.
*/
class AiConnection extends Page
{
use FollowsAdminMode;
protected static string|BackedEnum|null $navigationIcon = Heroicon::OutlinedSparkles;
protected static string|UnitEnum|null $navigationGroup = 'System';
protected static ?string $navigationLabel = 'KI-Anbindung';
protected static ?string $title = 'KI-Anbindung';
protected static ?string $slug = 'ki-anbindung';
protected static ?int $navigationSort = 3;
/** @var array<string, mixed> */
public array $data = [];
public static function canAccess(): bool
{
return (bool) auth()->user()?->hasRole(UserRole::Admin) && app(TenantFeatures::class)->enabled(TenantServiceKey::AiGuestMail);
}
public function mount(): void
{
$settings = (array) $this->service()?->settings;
// The key is never put into the form.
$this->form->fill([
'provider' => $settings['provider'] ?? null,
'small_model' => $settings['small_model'] ?? null,
'review_model' => $settings['review_model'] ?? null,
'api_key' => null,
]);
}
public function form(Schema $schema): Schema
{
return $schema
->statePath('data')
->components([
Section::make('Ihr Zugang')
->description('Die Auswertung von Gast-Nachrichten nutzt Ihren eigenen Zugang bei einem KI-Anbieter; die Kosten rechnet der Anbieter mit Ihnen ab. Nachrichten werden dafür an den Anbieter übermittelt – bitte Auftragsverarbeitung und Datenschutzhinweise beachten. Ohne gültigen Zugang bleibt jede Nachricht zur Prüfung im Posteingang.')
->columns(2)
->schema([
Select::make('provider')->label('Anbieter')->options(AiProvider::class)->required()->live(),
TextInput::make('api_key')->label('API-Schlüssel')->password()->autocomplete('new-password')->maxLength(500)
->placeholder(fn (): string => filled($this->service()?->api_key) ? 'gespeichert – leer lassen, um ihn zu behalten' : 'noch keiner gespeichert')
->helperText('Wird verschlüsselt gespeichert und nie wieder angezeigt.'),
TextInput::make('small_model')->label('Modell für die erste Auswertung (klein, günstig)')->required()->maxLength(150)
->helperText(fn (Get $get): string => self::provider($get('provider'))?->modelExamples() ?? 'Kennung des Modells beim Anbieter'),
TextInput::make('review_model')->label('Modell für die Prüfung unsicherer Fälle (groß)')->required()->maxLength(150)
->helperText('Wird nur gefragt, wenn eine Angabe widersprüchlich, unplausibel oder unsicher ist.'),
]),
Section::make('Stand')
->schema([Text::make(fn (): string => $this->checkSummary())]),
]);
}
public function content(Schema $schema): Schema
{
return $schema->components([
Form::make([EmbeddedSchema::make('form')])
->id('form')
->livewireSubmitHandler('save')
->footer([Actions::make([
Action::make('save')->label('Speichern')->submit('save'),
Action::make('check')->label('Verbindung prüfen')->color('gray')->icon(Heroicon::OutlinedSignal)->action(fn () => $this->check()),
Action::make('removeKey')->label('Schlüssel entfernen')->color('danger')->requiresConfirmation()
->modalDescription('Danach ist die automatische Auswertung aus, bis ein neuer Schlüssel gespeichert ist.')
->visible(fn (): bool => filled($this->service()?->api_key))
->action(fn () => $this->removeKey()),
])]),
]);
}
public function save(): void
{
$state = $this->form->getState();
$service = $this->service() ?? new TenantService(['tenant_id' => $this->tenant()->id, 'service' => TenantServiceKey::AiGuestMail->value, 'is_enabled' => true]);
$service->settings = ['provider' => self::provider($state['provider'])?->value, 'small_model' => trim((string) $state['small_model']), 'review_model' => trim((string) $state['review_model'])];
if (filled($state['api_key'] ?? null)) {
$service->api_key = trim((string) $state['api_key']);
}
// A changed access is checked again before it counts as rejected.
$service->forceFill(['check_status' => null, 'check_message' => null])->save();
$this->data['api_key'] = null;
Notification::make()->title('Gespeichert')->body(filled($service->api_key) ? 'Bitte „Verbindung prüfen“ ausführen.' : 'Ohne Schlüssel bleibt die Auswertung aus.')->success()->send();
}
/**
* Sends a minimal structured request to both models; the result is stored, the key never shown.
*/
public function check(): void
{
$service = $this->service();
$access = $service === null ? null : AiAccess::fromService($service);
if ($access === null) {
Notification::make()->title('Unvollständig')->body('Bitte Anbieter, Schlüssel und beide Modelle speichern.')->warning()->send();
return;
}
$schema = ['type' => 'object', 'additionalProperties' => false, 'required' => ['ok'], 'properties' => ['ok' => ['type' => 'boolean']]];
try {
foreach ([$access->smallModel, $access->reviewModel] as $model) {
app(LlmClient::class)->structured($access, $model, 'Answer with {"ok": true}.', 'Test', $schema, 'low');
}
} catch (ExtractionFailed $exception) {
$service->forceFill(['check_status' => AiAccess::INVALID, 'check_message' => mb_substr($exception->getMessage(), 0, 500), 'checked_at' => now()])->save();
Notification::make()->title('Prüfung fehlgeschlagen')->body($exception->getMessage())->danger()->send();
return;
}
$service->forceFill(['check_status' => AiAccess::OK, 'check_message' => null, 'checked_at' => now()])->save();
Notification::make()->title('Verbindung in Ordnung')->body('Beide Modelle antworten im erwarteten Format.')->success()->send();
}
public function removeKey(): void
{
$this->service()?->forceFill(['api_key' => null, 'check_status' => null, 'check_message' => null, 'checked_at' => null])->save();
Notification::make()->title('Schlüssel entfernt')->success()->send();
}
private static function provider(mixed $value): ?AiProvider
{
return $value instanceof AiProvider ? $value : AiProvider::tryFrom((string) $value);
}
private function checkSummary(): string
{
$service = $this->service();
if ($service === null || blank($service->api_key)) {
return 'Kein Zugang gespeichert – Nachrichten werden nicht automatisch ausgewertet.';
}
return match ($service->check_status) {
AiAccess::OK => 'Zuletzt erfolgreich geprüft am '.$service->checked_at?->format('d.m.Y, H:i').' Uhr.',
AiAccess::INVALID => 'Abgelehnt am '.$service->checked_at?->format('d.m.Y, H:i').' Uhr: '.$service->check_message.' Die automatische Auswertung ist aus.',
default => 'Gespeichert, noch nicht geprüft.',
};
}
private function service(): ?TenantService
{
return AiAccess::service($this->tenant());
}
private function tenant(): Tenant
{
$tenant = Settings::tenant();
abort_if($tenant === null, 404);
return $tenant;
}
}
+37 -2
View File
@@ -12,6 +12,7 @@
use App\Models\Property;
use App\Process\ProcessProfile;
use App\Process\ProcessSettings;
use App\Support\Money;
use BackedEnum;
use Filament\Pages\Page;
use Filament\Support\Icons\Heroicon;
@@ -63,8 +64,11 @@ public function matrix(): array
$settings = app(ProcessSettings::class);
return Property::query()->orderBy('name')->get()->map(function (Property $property) use ($settings): array {
$columns = [['label' => 'Direkte Anfrage (Webseite, Telefon)', 'profile' => $settings->resolve($property, null, IntakeKind::Inquiry)]];
foreach (Channel::query()->where('property_id', $property->id)->orderBy('name')->get() as $channel) {
$columns = [
['label' => 'Eigene Webseite – Anfrage', 'profile' => $settings->forWebsite($property)],
['label' => 'Direkte Anfrage (Telefon, E-Mail)', 'profile' => $settings->resolve($property, null, IntakeKind::Inquiry)],
];
foreach (Channel::query()->portals()->where('property_id', $property->id)->orderBy('name')->get() as $channel) {
$columns[] = ['label' => $channel->name.' – Anfrage', 'profile' => $settings->resolve($property, $channel, IntakeKind::Inquiry)];
$columns[] = ['label' => $channel->name.' – feste Buchung', 'profile' => $settings->resolve($property, $channel, IntakeKind::Booking)];
}
@@ -102,6 +106,37 @@ public static function where(ProcessSetting $setting): string
: 'System › So arbeite ich; Abweichung: Wohnung (Experte), Portal je Anfrage/feste Buchung'.($setting->channelIntakes() === [] ? ' (kein Portal)' : '');
}
/**
* What a request on this way is answered with (package 7): a binding offer that reserves, or an information.
*/
public static function answer(ProcessProfile $profile): string
{
return match ($profile->intake) {
IntakeKind::Inquiry => $profile->preReservation() ? 'Angebot mit Annahmelink, Zeitraum reserviert' : 'Unverbindliche Auskunft, „Buchung anfragen“, erneute Prüfung',
IntakeKind::Booking => 'keine – beim Portal bereits verbindlich',
IntakeKind::Internal => 'keine – eigene Belegung',
};
}
/**
* The stay settings of a property in one line (package 9).
*/
public static function stay(Property $property): string
{
$tasks = array_map(fn (array $task): string => $task['title'].' ('.match ($task['when']) {
'after_departure' => 'am Abreisetag',
'on_arrival' => 'am Anreisetag',
default => $task['days'].' Tag(e) vor Anreise',
}.($task['responsible'] ? ', '.$task['responsible'] : '').')', $property->stayTaskDefinitions());
return implode(' · ', [
'Anreisezeit erfragen: '.($property->asks_arrival_time ? 'ja' : 'nein'),
'Aufgaben je Aufenthalt: '.($tasks === [] ? 'keine eingestellt' : implode(', ', $tasks)),
'gebuchte Leistungen werden zu Aufgaben',
'Kurabgabe (A6): '.($property->tourist_tax_rate ? Money::format((int) $property->tourist_tax_rate).' je Person und Nacht' : 'kein Satz – keine Berechnung'),
]);
}
/**
* Recent cases to check.
*
+84 -8
View File
@@ -3,15 +3,19 @@
namespace App\Filament\Pages;
use App\Actions\SendDigests;
use App\Channels\ChannelSyncException;
use App\Channels\Mail\MailboxReader;
use App\Enums\DigestSection;
use App\Enums\TenantServiceKey;
use App\Enums\UserRole;
use App\Filament\Concerns\FollowsAdminMode;
use App\Models\Mailbox;
use App\Models\Tenant;
use App\Support\Settings;
use App\Tenancy\TenantConfig;
use App\Tenancy\TenantFeatures;
use BackedEnum;
use Carbon\CarbonImmutable;
use Filament\Actions\Action;
use Filament\Forms\Components\CheckboxList;
use Filament\Forms\Components\Radio;
@@ -29,6 +33,7 @@
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Schema;
use Filament\Support\Icons\Heroicon;
use Illuminate\Support\Facades\Cache;
use UnitEnum;
/**
@@ -102,12 +107,14 @@ public function mount(): void
'bank_iban' => $tenant->bank_iban,
'bank_bic' => $tenant->bank_bic,
'tax_note' => $tenant->tax_note,
'mailbox_host' => $tenant->mailbox_host,
'mailbox_port' => $tenant->mailbox_port,
'mailbox_username' => $tenant->mailbox_username,
'mailbox_password' => $tenant->mailbox_password,
'mailbox_encryption' => $tenant->mailbox_encryption,
'mailbox_folder' => $tenant->mailbox_folder,
'mailbox_host' => $tenant->activeMailbox()?->host ?? $tenant->mailbox_host,
'mailbox_port' => $tenant->activeMailbox()?->port ?? $tenant->mailbox_port,
'mailbox_username' => $tenant->activeMailbox()?->username ?? $tenant->mailbox_username,
'mailbox_password' => $tenant->activeMailbox()?->password ?? $tenant->mailbox_password,
'mailbox_encryption' => $tenant->activeMailbox()?->encryption ?? $tenant->mailbox_encryption,
'mailbox_folder' => $tenant->activeMailbox()?->folder ?? $tenant->mailbox_folder,
'mailbox_address' => $tenant->activeMailbox()?->address,
'mailbox_mode' => $tenant->activeMailbox()?->mode ?? Mailbox::PORTAL_ONLY,
'reminder_interval_days' => $tenant->reminder_interval_days,
'digest_daily' => $tenant->digest_daily,
'digest_weekly' => $tenant->digest_weekly,
@@ -247,8 +254,20 @@ public function form(Schema $schema): Schema
Select::make('mailbox_encryption')
->label('Verschlüsselung')
->options(['ssl' => 'SSL', 'tls' => 'TLS', 'starttls' => 'STARTTLS'])
->placeholder('SSL'),
TextInput::make('mailbox_folder')->label('Ordner')->placeholder('INBOX')->maxLength(190),
->placeholder('Standard (SSL)'),
TextInput::make('mailbox_folder')->label('Ordner')->placeholder('INBOX')->maxLength(190)
->helperText('Leer lassen für den Posteingang (auf dem Server „INBOX“, auch „Posteingang“ wird erkannt).'),
Select::make('mailbox_mode')->label('Was wird gelesen?')
->options([Mailbox::PORTAL_ONLY => 'Nur Buchungsmails der Portale (wie bisher)', Mailbox::FULL => 'Alle Nachrichten (eigenes Postfach für die Gästekommunikation)'])
->required()
->helperText('„Alle Nachrichten“ nur für ein Postfach, das ausschließlich für Anfragen und Gästeantworten dient: Antworten und Gast-Mails werden dann den Vorgängen zugeordnet oder im Posteingang zur Klärung gezeigt.'),
TextInput::make('mailbox_address')->label('Adresse dieses Postfachs (für Antworten der Gäste)')->email()->maxLength(190)
->helperText('Rückfragen nennen diese Adresse als Antwortadresse, damit die Antwort hier ankommt.'),
Text::make(fn (): string => $this->mailboxState())->columnSpanFull(),
Actions::make([
Action::make('checkMailbox')->label('Postfach prüfen')->icon(Heroicon::OutlinedSignal)->color('gray')
->action(fn () => $this->checkMailbox()),
])->columnSpanFull(),
]),
Section::make('Fristen und Grenzen')
->description('Leer bedeutet: die Vorgabe des Systems gilt. Löschfristen und Bot-Schutz lassen sich verschärfen, aber nicht über die Vorgabe hinaus lockern.')
@@ -291,6 +310,47 @@ protected function getHeaderActions(): array
];
}
/**
* Connects to the saved mailbox and counts the messages of the last days; nothing is read or marked.
*/
public function checkMailbox(): void
{
$connection = $this->tenant()->mailbox();
if ($connection === null) {
Notification::make()->title('Kein Postfach gespeichert')->body('Bitte Server und Benutzer eintragen und speichern.')->warning()->send();
return;
}
try {
$count = app(MailboxReader::class)->probe($connection);
} catch (ChannelSyncException $exception) {
Notification::make()->title('Postfach nicht erreichbar')->body($exception->getMessage())->danger()->persistent()->send();
return;
}
Notification::make()->title('Verbindung in Ordnung')->body($count.' Nachricht(en) der letzten '.config('fewo.mailbox.lookback_days', 3).' Tage im Ordner „'.$connection['folder'].'“.')->success()->send();
}
/**
* When the mailbox was last read and whether the last attempt failed.
*/
private function mailboxState(): string
{
$mailbox = $this->tenant()->activeMailbox();
if ($mailbox === null || blank($mailbox->host)) {
return 'Kein Postfach eingerichtet.';
}
$error = Cache::get(MailboxReader::key(MailboxReader::LAST_ERROR_KEY));
$success = Cache::get(MailboxReader::key(MailboxReader::LAST_SUCCESS_KEY));
return 'Abruf jede Minute. Zuletzt erfolgreich gelesen: '.($success ? CarbonImmutable::parse($success)->format('d.m.Y, H:i').' Uhr' : 'noch nie')
.($error ? ' · Letzter Fehler: '.mb_substr((string) $error, 0, 200) : '')
.($mailbox->readsEverything() ? ' · Eingegangene Nachrichten stehen unter Verwaltung › Posteingang.' : ' · Gelesen werden nur Buchungsmails der Portale.');
}
public function save(): void
{
$data = $this->form->getState();
@@ -329,6 +389,22 @@ public function save(): void
...array_map(fn (mixed $value): ?int => filled($value) ? (int) $value : null, $this->periodInput($data)),
]);
// v0.11 (CH-05): the active mailbox record leads; it is kept in step with the fields above.
$mailbox = $tenant->activeMailbox() ?? new Mailbox(['is_active' => true]);
$mailbox->forceFill(['tenant_id' => $tenant->id])->fill([
'host' => $data['mailbox_host'] ?? null,
'port' => filled($data['mailbox_port'] ?? null) ? (int) $data['mailbox_port'] : null,
'username' => $data['mailbox_username'] ?? null,
'password' => $data['mailbox_password'] ?? null,
'encryption' => $data['mailbox_encryption'] ?? null,
'folder' => $data['mailbox_folder'] ?? null,
'address' => $data['mailbox_address'] ?? null,
'mode' => $data['mailbox_mode'] ?? Mailbox::PORTAL_ONLY,
]);
if ($mailbox->exists || filled($mailbox->host)) {
$mailbox->save();
}
app(TenantConfig::class)->refresh();
if ($data['mode'] === Settings::MODE_LIVE && ! $wasLive) {
@@ -147,7 +147,7 @@ public static function portalActions(): array
->mapWithKeys(fn (BlockedPeriod $block): array => [$block->id => '#'.$block->id.' · '.$block->occupationKind()->getLabel().' · '.($block->reason ?? 'Kalenderbelegung').($block->leading_priority ? ' · bevorzugter Führungskandidat' : '')])->all();
}),
Select::make('origin_channel_id')->label('Ursprünglicher Buchungskanal, sofern persönlich bekannt')
->options(fn (BlockedPeriod $record): array => Channel::query()->where('property_id', $record->property_id)->pluck('name', 'id')->all())
->options(fn (BlockedPeriod $record): array => Channel::query()->portals()->where('property_id', $record->property_id)->pluck('name', 'id')->all())
->default(fn (BlockedPeriod $record): ?int => $record->origin_channel_id)->placeholder('Unbekannt / eigene Vermietung'),
])
->action(function (BlockedPeriod $record, array $data, ResolveChannelOccupation $resolve): void {
@@ -8,6 +8,7 @@
use App\Filament\Resources\Bookings\Pages\CreateBooking;
use App\Filament\Resources\Bookings\Pages\ListBookings;
use App\Filament\Resources\Bookings\Pages\ViewBooking;
use App\Filament\Resources\Bookings\RelationManagers\InboundMessagesRelationManager;
use App\Filament\Resources\Bookings\RelationManagers\MessagesRelationManager;
use App\Filament\Resources\Bookings\RelationManagers\PaymentsRelationManager;
use App\Filament\Resources\Bookings\RelationManagers\TasksRelationManager;
@@ -76,6 +77,7 @@ public static function getRelations(): array
PaymentsRelationManager::class,
TasksRelationManager::class,
MessagesRelationManager::class,
InboundMessagesRelationManager::class,
];
}
@@ -0,0 +1,272 @@
<?php
namespace App\Filament\Resources\Bookings\Pages\Concerns;
use App\Actions\CloseStay;
use App\Actions\DecideBookingWish;
use App\Actions\PrepareStays;
use App\Actions\SendInformation;
use App\Actions\SendOffer;
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\DocumentKind;
use App\Enums\IntakeKind;
use App\Filament\Forms\DocumentCompositionFields;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Pricing\StayRequest;
use App\Process\CaseClosure;
use App\Process\CaseLog;
use App\Support\Money;
use Filament\Actions\Action;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\DateTimePicker;
use Filament\Forms\Components\Hidden;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Schemas\Components\Section;
use Filament\Schemas\Components\Text;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Support\Icons\Heroicon;
use Throwable;
/**
* Case page actions of packages 7 and 9: the information "unter Vorbehalt" and the decision on a booking wish; arrival
* details, tasks of the stay (done, handed over, newly noted), closing the stay and settling the case commercially.
*
* @property Booking $record
*/
trait HandlesWishAndStay
{
private function sendInformationAction(): Action
{
return Action::make('sendInformation')
->label(fn (): string => $this->record->information_version > 0 ? 'Auskunft ändern & neu senden' : 'Unverbindliche Auskunft prüfen und senden')
->icon(Heroicon::OutlinedPaperAirplane)
->visible(fn (): bool => in_array($this->record->status, [BookingStatus::Reserved, BookingStatus::Expired], true) && $this->record->intake !== IntakeKind::Booking
&& ! $this->record->process()->preReservation() && $this->record->offer_version === 0 && ! $this->record->isHoldActive())
->modalHeading('Unverbindliche Auskunft an den Gast')
->modalDescription('Nach Ihrer Einstellung reservieren Anfragen den Zeitraum nicht. Der Gast erhält Preis und Verfügbarkeit zum heutigen Stand und kann daraus die Buchung anfragen; dann wird erneut geprüft. Verbindlich wird erst Ihre (oder die automatische) Bestätigung.')
->modalSubmitActionLabel('Senden')
->modalWidth('4xl')
->fillForm(fn (): array => [
'expected_version' => $this->record->information_version,
'arrival' => $this->record->arrival->toDateString(),
'departure' => $this->record->departure->toDateString(),
'guests' => $this->record->guests,
'promo_code' => $this->record->promo_code,
'price_adjustment' => $this->record->price_adjustment !== null ? number_format($this->record->price_adjustment / 100, 2, '.', '') : null,
'price_adjustment_label' => $this->record->price_adjustment_label,
'valid_until' => now()->addHours($this->record->process()->holdHours())->format('Y-m-d H:i'),
'offer_message' => $this->record->offer_message,
])
->schema([
Hidden::make('expected_version'),
...DocumentCompositionFields::make($this->record, DocumentKind::Information, fn (Get $get): array => $this->offerChanges(self::formState($get, ['expected_version', 'arrival', 'departure', 'guests', 'promo_code', 'price_adjustment', 'price_adjustment_label', 'valid_until', 'offer_message']))),
Textarea::make('offer_message')->label('Persönliche Nachricht an den Gast (optional)')->rows(3)->live(onBlur: true),
Section::make('Anpassen')->description('Zeitraum, Preis und wie lange der Gast die Buchung anfragen kann.')->collapsed()->schema([
Section::make('Termin')->columns(3)->schema([
DatePicker::make('arrival')->label('Anreise')->required()->live(onBlur: true),
DatePicker::make('departure')->label('Abreise')->after('arrival')->required()->live(onBlur: true),
TextInput::make('guests')->label('Personen')->integer()->minValue(1)->maxValue(fn (): int => $this->record->property->max_guests)->required()->live(onBlur: true),
]),
Section::make('Preis')->columns(3)->schema([
TextInput::make('promo_code')->label('Rabattcode')->maxLength(50)->live(onBlur: true),
TextInput::make('price_adjustment')->label('Preisanpassung')->helperText('Minus = Nachlass, z. B. -50')->numeric()->step(0.01)->suffix('€')->live(onBlur: true),
TextInput::make('price_adjustment_label')->label('Bezeichnung')->placeholder('Nachlass / Zuschlag')->maxLength(80)->live(onBlur: true),
]),
DateTimePicker::make('valid_until')->label('Buchung anfragen bis')->helperText('Der Zeitraum bleibt bis dahin trotzdem frei buchbar für andere.')->seconds(false)->after('now')->required()->live(onBlur: true),
]),
])
->action(fn (array $data, SendInformation $send) => $this->runWorkflow(fn () => $send->handle($this->record, $this->offerChanges($data)), 'Auskunft gesendet'));
}
private function decideWishAction(): Action
{
return Action::make('decideWish')
->label('Buchungswunsch bestätigen oder absagen …')
->icon(Heroicon::OutlinedCheckCircle)
->visible(fn (): bool => $this->record->status === BookingStatus::Reserved && $this->record->wish_at !== null)
->modalHeading('Buchungswunsch des Gastes')
->modalDescription(fn (): string => 'Angefragt am '.$this->record->wish_at?->format('d.m.Y, H:i').' Uhr. Bei „Bestätigen“ wird die Verfügbarkeit noch einmal geprüft; der Gast erhält die Buchungsbestätigung mit dem Mietvertrag.')
->modalSubmitActionLabel('Ausführen')
->schema(fn (): array => [
Text::make($this->wishCheckText()),
Radio::make('decision')->label('Entscheidung')->required()->default('confirm')->live()->options(array_filter([
'confirm' => 'Bestätigen zum Preis der Auskunft ('.Money::format((int) $this->record->total).')',
'confirm_today' => $this->todaysTotal() !== null && $this->todaysTotal() < (int) $this->record->total ? 'Bestätigen zum heutigen, niedrigeren Preis ('.Money::format((int) $this->todaysTotal()).')' : null,
'decline' => 'Absagen – der Gast erhält eine freundliche Absage',
])),
Textarea::make('reason')->label('Grund (nur für den Verlauf)')->rows(2)->visible(fn (Get $get): bool => $get('decision') === 'decline'),
])
->action(function (array $data, DecideBookingWish $decide): void {
$this->runWorkflow(fn () => match ($data['decision']) {
'decline' => $decide->decline($this->record, $data['reason'] ?? null),
default => $decide->confirm($this->record, $data['decision'] === 'confirm_today'),
}, $data['decision'] === 'decline' ? 'Abgesagt' : 'Buchung bestätigt');
});
}
private function arrivalDetailsAction(): Action
{
return Action::make('arrivalDetails')
->label('Anreisedaten eintragen')
->icon(Heroicon::OutlinedClock)
->visible(fn (): bool => $this->record->isBinding() && ! $this->record->isInternal() && $this->record->departure->isFuture())
->modalHeading('Anreisedaten')
->modalDescription('Aus Portalnachricht, E-Mail oder Telefonat. Was fehlt, steht in der Aufgabe; nur Bekanntes eintragen.')
->fillForm(fn (): array => ['arrival_time' => $this->record->arrival_time, 'email' => $this->record->guest?->email, 'phone' => $this->record->guest?->phone])
->schema([
TextInput::make('arrival_time')->label('Anreisezeit')->placeholder('z. B. gegen 16 Uhr')->maxLength(40),
TextInput::make('phone')->label('Telefon des Gastes')->tel()->maxLength(50)->visible(fn (): bool => $this->record->guest !== null),
TextInput::make('email')->label('E-Mail des Gastes')->email()->maxLength(255)->visible(fn (): bool => $this->record->guest !== null),
])
->action(function (array $data): void {
$this->record->update(['arrival_time' => filled($data['arrival_time'] ?? null) ? trim((string) $data['arrival_time']) : null]);
if ($this->record->guest !== null) {
$this->record->guest->update(array_filter(['phone' => $data['phone'] ?? null, 'email' => isset($data['email']) ? mb_strtolower(trim((string) $data['email'])) : null], fn ($value): bool => filled($value)));
}
app(PrepareStays::class)->handle();
$this->record->refresh();
Notification::make()->title('Gespeichert')->success()->send();
});
}
private function completeTaskAction(): Action
{
return Action::make('completeTask')
->label('Aufgabe erledigen …')
->icon(Heroicon::OutlinedCheck)
->visible(fn (): bool => $this->openTasks() !== [])
->modalHeading('Aufgabe erledigen')
->modalDescription('Erledigt oder an jemanden übergeben (z. B. Reinigung, Portal, Steuerberater). Die Notiz steht im Verlauf.')
->fillForm(fn (): array => ['task' => array_key_first($this->openTasks()), 'outcome' => 'done'])
->schema([
Select::make('task')->label('Aufgabe')->options(fn (): array => $this->openTasks())->required(),
Radio::make('outcome')->label('Ergebnis')->required()->options([
'done' => 'Erledigt',
'handed_over' => 'Übergeben – jemand anderes kümmert sich',
'dismissed' => 'Entfällt',
])->live(),
TextInput::make('handed_to')->label('Übergeben an')->maxLength(120)->required(fn (Get $get): bool => $get('outcome') === 'handed_over')->visible(fn (Get $get): bool => $get('outcome') === 'handed_over'),
Textarea::make('note')->label('Notiz')->rows(2)->maxLength(1000),
])
->action(function (array $data): void {
$task = BookingTask::query()->where('booking_id', $this->record->id)->whereKey($data['task'])->where('status', BookingTaskStatus::Open)->first();
if ($task === null) {
Notification::make()->title('Diese Aufgabe ist schon erledigt.')->warning()->send();
return;
}
$note = trim(implode(' · ', array_filter([$data['outcome'] === 'handed_over' ? 'Übergeben an '.$data['handed_to'] : null, $data['note'] ?? null])));
if ($data['outcome'] === 'dismissed') {
$task->update(['status' => BookingTaskStatus::Dismissed, 'note' => $note !== '' ? $note : $task->note, 'completed_by' => CaseLog::actor(), 'completed_at' => now()]);
} else {
if ($data['outcome'] === 'handed_over') {
$task->responsible = (string) $data['handed_to'];
}
$task->complete(CaseLog::actor(), $note !== '' ? $note : null);
}
$this->record->refresh();
Notification::make()->title('Aufgabe vermerkt')->success()->send();
});
}
private function addTaskAction(): Action
{
return Action::make('addTask')
->label('Abweichung oder Aufgabe festhalten …')
->icon(Heroicon::OutlinedPencilSquare)
->visible(fn (): bool => in_array($this->record->status, [...BookingStatus::occupying(), BookingStatus::Cancelled], true))
->modalHeading('Abweichung oder Aufgabe festhalten')
->modalDescription('Zum Aufenthalt (z. B. späte Anreise, defekte Kaffeemaschine, Schaden) – als Aufgabe am Vorgang, keine eigene Verwaltung.')
->schema([
Radio::make('kind')->label('Art')->required()->default(BookingTaskKind::Issue->value)->options([
BookingTaskKind::Issue->value => 'Abweichung oder Problem beim Aufenthalt – muss vor dem Abschluss des Aufenthalts geklärt sein',
BookingTaskKind::Service->value => 'Leistung vorbereiten (z. B. Kinderbett, zusätzliche Reinigung)',
BookingTaskKind::FollowUp->value => 'Folgeaufgabe nach dem Aufenthalt (z. B. Schaden abrechnen, Reparatur) – hält den Abschluss nicht auf',
]),
TextInput::make('title')->label('Was?')->required()->maxLength(200),
TextInput::make('responsible')->label('Wer kümmert sich? (optional)')->placeholder('z. B. Reinigung Müller')->maxLength(120),
DatePicker::make('due_on')->label('Bis wann? (optional)'),
Textarea::make('note')->label('Notiz')->rows(2)->maxLength(1000),
])
->action(function (array $data): void {
BookingTask::openOnce($this->record, BookingTaskKind::from($data['kind']), 'manual:'.now()->format('YmdHisv'), [
'title' => trim((string) $data['title']),
'responsible' => filled($data['responsible'] ?? null) ? trim((string) $data['responsible']) : null,
'due_on' => $data['due_on'] ?? null,
'note' => $data['note'] ?? null,
]);
$this->record->refresh();
Notification::make()->title('Festgehalten')->success()->send();
});
}
private function closeStayAction(): Action
{
return Action::make('closeStay')
->label(fn (): string => $this->record->isInternal() ? 'Abschließen …' : 'Aufenthalt abschließen …')
->icon(Heroicon::OutlinedFlag)
->visible(fn (): bool => in_array($this->record->status, [BookingStatus::Confirmed, BookingStatus::DepositPaid, BookingStatus::Paid], true) && ! $this->record->departure->isFuture())
->modalHeading('Aufenthalt abschließen')
->modalDescription(fn (): string => ($blockers = CaseClosure::stayBlockers($this->record))->isEmpty()
? 'Für den Aufenthalt ist nichts mehr offen. Offene Zahlungen oder Auszahlungen bleiben als kaufmännische Punkte am Vorgang.'
: 'Noch offen für den Aufenthalt: '.$blockers->map(fn (BookingTask $task): string => $task->label())->implode(', ').'. Mit dem Abschluss werden sie als erledigt bzw. übergeben vermerkt.')
->schema([Textarea::make('note')->label('Notiz (z. B. „Reinigung erledigt, Schlüssel zurück“)')->rows(2)->maxLength(500)])
->action(fn (array $data, CloseStay $close) => $this->runWorkflow(fn () => $close->byHand($this->record, CaseLog::actor(), $data['note'] ?? null), 'Aufenthalt abgeschlossen'));
}
private function settleAction(): Action
{
return Action::make('settle')
->label('Kaufmännisch abschließen …')
->icon(Heroicon::OutlinedBanknotes)
->visible(fn (): bool => in_array($this->record->status, [BookingStatus::Completed, BookingStatus::Cancelled], true) && $this->record->settled_at === null)
->modalHeading('Kaufmännisch abschließen')
->modalDescription(fn (): string => 'Noch offen: '.implode(' ', CaseClosure::commercialPoints($this->record)).' Abschließen nur, wenn das geklärt ist (z. B. kleine Differenz akzeptiert, Forderung ausgebucht).')
->schema([Textarea::make('note')->label('Begründung')->required()->rows(2)->maxLength(500)])
->action(function (array $data): void {
CaseClosure::settle($this->record, trim((string) $data['note']), CaseLog::actor());
$this->record->refresh();
Notification::make()->title('Kaufmännisch abgeschlossen')->success()->send();
});
}
/**
* Open tasks the landlord can settle on the page (not the ones with an action of their own).
*
* @return array<int, string>
*/
private function openTasks(): array
{
return BookingTask::query()->where('booking_id', $this->record->id)->where('status', BookingTaskStatus::Open)
->whereNotIn('kind', [BookingTaskKind::BookingWish, BookingTaskKind::CancellationRequest, BookingTaskKind::PortalCancellation, BookingTaskKind::PortalCancellationReported, BookingTaskKind::DepositReminder, BookingTaskKind::BalanceRequest, BookingTaskKind::BalanceReminder])
->orderByRaw('due_on is null')->orderBy('due_on')->orderBy('id')->get()
->mapWithKeys(fn (BookingTask $task): array => [$task->id => $task->label().($task->due_on ? ' (fällig '.$task->due_on->format('d.m.Y').')' : '')])->all();
}
private function wishCheckText(): string
{
$wish = (array) ($this->record->wish ?? []);
$findings = (array) ($wish['findings'] ?? []);
$available = app(AvailabilityChecker::class)->isAvailable($this->record->property, $this->record->arrival, $this->record->departure, ignore: $this->record);
return ($available ? 'Der Zeitraum ist im Moment frei. ' : 'Achtung: Der Zeitraum ist inzwischen belegt – bitte absagen. ')
.($findings === [] ? 'Bei der Prüfung des Wunsches war alles in Ordnung.' : 'Bei der Prüfung des Wunsches fiel auf: '.implode(' ', $findings));
}
private function todaysTotal(): ?int
{
try {
return app(SendOffer::class)->quoteFor($this->record, new StayRequest($this->record->arrival, $this->record->departure, $this->record->guests, $this->record->extras ?? [], $this->record->promo_code), (int) $this->record->price_adjustment, (string) ($this->record->price_adjustment_label ?: 'Zuschlag'))->total();
} catch (Throwable) {
return null;
}
}
}
@@ -47,7 +47,7 @@ protected function handleRecordCreation(array $data): Model
$channel = filled($data['channel_id'] ?? null) ? Channel::query()->findOrFail($data['channel_id']) : null;
$arrival = CarbonImmutable::parse($data['arrival']);
$departure = CarbonImmutable::parse($data['departure']);
$guest = Arr::only($data, ['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city']);
$guest = Arr::only($data, ['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city', 'country']);
if ($data['kind'] === BookingForm::EXTERNAL) {
return app(TakeOverExternalBooking::class)->handle($property, $channel, $arrival, $departure, [
@@ -9,11 +9,13 @@
use App\Actions\EndInternalCase;
use App\Actions\ProvideGuestContact;
use App\Actions\RecordPortalAmounts;
use App\Actions\RequestCaseData;
use App\Actions\SendBookingDocuments;
use App\Actions\SendOffer;
use App\Actions\SetBookingStatus;
use App\Documents\OfferTerms;
use App\Documents\RentalContract;
use App\Enums\ActivityState;
use App\Enums\AdminMode;
use App\Enums\AmountKind;
use App\Enums\BookingStatus;
@@ -31,18 +33,24 @@
use App\Filament\Forms\Components\EuroInput;
use App\Filament\Forms\DocumentCompositionFields;
use App\Filament\Resources\Bookings\BookingResource;
use App\Filament\Resources\Bookings\Pages\Concerns\HandlesWishAndStay;
use App\Models\Booking;
use App\Models\BookingChange;
use App\Models\BookingTask;
use App\Models\ContractAnnex;
use App\Models\ContractTemplate;
use App\Models\DataRequest;
use App\Models\Extra;
use App\Models\User;
use App\Pricing\PrivateStayPrice;
use App\Pricing\QuoteException;
use App\Process\Activity;
use App\Process\ActivityDetails;
use App\Process\CaseActivities;
use App\Process\CaseAutomation;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use App\Support\Countries;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Filament\Actions\Action;
@@ -79,6 +87,8 @@
*/
class ViewBooking extends ViewRecord
{
use HandlesWishAndStay;
protected static string $resource = BookingResource::class;
/** Actions for the expert view only. */
@@ -94,12 +104,39 @@ public function getSubheading(): string|Htmlable|null
return CaseActivities::situation($this->record);
}
/**
* Filament builds the header actions before an action runs; rebuild them afterwards so the large button already
* shows the next step instead of the one just done.
*/
protected function afterActionCalled(Action $action): void
{
parent::afterActionCalled($action);
$fresh = $this->record->exists ? $this->record->fresh() : null;
if ($fresh === null) {
return;
}
$this->record = $fresh;
$this->cachedHeaderActions = [];
$this->cacheInteractsWithHeaderActions();
}
protected function getHeaderActions(): array
{
$actions = collect([
$this->sendInformationAction(),
$this->decideWishAction(),
$this->sendOfferAction(),
$this->provideContactAction(),
$this->arrivalDetailsAction(),
$this->completeTaskAction(),
$this->addTaskAction(),
$this->closeStayAction(),
$this->settleAction(),
$this->requestContactAction(),
$this->approveDataRequestAction(),
$this->stopDataRequestAction(),
AssignGuestAction::make(),
$this->confirmAction(),
$this->sendDocumentsAction(),
@@ -119,7 +156,9 @@ protected function getHeaderActions(): array
$this->setStatusAction(),
])->keyBy(fn (Action $action): string => $action->getName());
$next = CaseActivities::next($this->record)?->action;
// While the case waits for the guest's missing details, entering them oneself (call, other mail) is the step at hand.
$next = CaseActivities::next($this->record)?->action
?? collect(CaseActivities::for($this->record))->first(fn ($activity): bool => $activity->key === 'contact' && $activity->action !== null)?->action;
$primary = $next !== null && $actions->has($next) ? $actions->pull($next)->color('primary')->size('lg')->icon(Heroicon::OutlinedArrowRightCircle) : null;
$expert = $actions->only(self::EXPERT)->values()->all();
$more = $actions->except(self::EXPERT)->values()->all();
@@ -143,7 +182,11 @@ private function isExpert(): bool
private function sendOfferAction(): Action
{
return Action::make('sendOffer')
->label(fn (): string => $this->record->status === BookingStatus::OfferSent ? 'Angebot ändern & neu senden' : 'Angebot prüfen und senden')
->label(fn (): string => match (true) {
$this->record->status === BookingStatus::OfferSent => 'Angebot ändern & neu senden',
! $this->record->process()->preReservation() => 'Stattdessen verbindliches Angebot mit Reservierung senden',
default => 'Angebot prüfen und senden',
})
->icon(Heroicon::OutlinedPaperAirplane)
->visible(fn (): bool => in_array($this->record->status, [BookingStatus::Reserved, BookingStatus::OfferSent, BookingStatus::Expired], true) && $this->record->intake !== IntakeKind::Booking)
->modalHeading('Angebot an den Gast')
@@ -255,14 +298,18 @@ private function templateFields(): array
private function provideContactAction(): Action
{
return Action::make('provideContact')
->label(fn (): string => $this->record->guest === null ? 'Gast eintragen' : 'Kontaktdaten eintragen')
->label(fn (): string => match (true) {
$this->record->guest === null => 'Gast eintragen',
RequestCaseData::needs($this->record) !== null => 'Fehlende Angaben selbst eintragen',
default => 'Gastdaten bearbeiten',
})
->icon(Heroicon::OutlinedUserPlus)
->visible(fn (): bool => $this->record->internal_kind !== InternalKind::Block && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true))
->modalHeading('Kontaktdaten des Gastes')
->modalDescription('Aus Portalnachricht, E-Mail oder Telefonat. Nur eintragen, was bekannt ist.')
->modalDescription(fn (): string => 'Aus Telefonat, E-Mail, Portalnachricht oder Gespräch. Nur eintragen, was bekannt ist; Ihre Eingabe gilt und wird mit Herkunft „von Ihnen eingetragen“ festgehalten. Eine laufende Rückfrage endet, sobald alles da ist.'.$this->openFactConflicts())
->modalWidth('3xl')
->fillForm(fn (): array => [
'guest' => $this->record->guest?->only(['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city']) ?? [],
'guest' => $this->record->guest?->only(['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city', 'country']) ?? [],
'process' => $this->record->processingMode() === ProcessingMode::Automatic ? ProvideGuestContact::AUTOMATIC : ProvideGuestContact::MANUAL,
'guest_confirmed' => $this->record->guest_confirmed_at !== null,
])
@@ -275,6 +322,7 @@ private function provideContactAction(): Action
TextInput::make('guest.street')->label('Straße und Hausnummer')->maxLength(150),
TextInput::make('guest.postal_code')->label('PLZ')->maxLength(20),
TextInput::make('guest.city')->label('Ort')->maxLength(100),
Select::make('guest.country')->label('Land')->options(Countries::options())->placeholder('nicht bekannt'),
]),
Section::make('Wie geht es danach weiter?')->schema([
Radio::make('process')->hiddenLabel()->options([
@@ -299,6 +347,96 @@ private function provideContactAction(): Action
});
}
/**
* Details from the guest's side that differ from the stored ones (v0.11 fact intake), for the contact dialog.
*/
private function openFactConflicts(): string
{
$notes = $this->record->tasks()->where('kind', BookingTaskKind::FactConflict)->where('status', BookingTaskStatus::Open)->pluck('note')->all();
return $notes === [] ? '' : ' Abweichende Angaben des Gastes – bitte den richtigen Wert eintragen: '.implode(' · ', $notes);
}
/**
* What lies behind one step of the progress list (clicked in "Ablauf"): its history entries and – for the guest's
* details – each detail with source, time, evidence and certainty, with the way to correct it or to do the step.
*/
public function activityDetailsAction(): Action
{
return Action::make('activityDetails')
->modalHeading(fn (array $arguments): string => ActivityDetails::activity($this->record, (string) ($arguments['key'] ?? ''))?->label ?? 'Schritt')
->modalWidth('4xl')
->modalSubmitAction(false)
->modalCancelActionLabel('Schließen')
->modalContent(function (array $arguments): \Illuminate\Contracts\View\View {
$key = (string) ($arguments['key'] ?? '');
$activity = ActivityDetails::activity($this->record, $key);
return view('filament.activity-details', [
'activity' => $activity ?? new Activity($key, 'Schritt', ActivityState::NotApplicable),
'events' => ActivityDetails::events($this->record, $key),
'facts' => ActivityDetails::showsFacts($key) ? ActivityDetails::facts($this->record->loadMissing('guest')) : null,
]);
})
->extraModalFooterActions(fn (array $arguments): array => array_values(array_filter([
ActivityDetails::showsFacts((string) ($arguments['key'] ?? '')) && $this->record->internal_kind !== InternalKind::Block
? Action::make('correctFacts')->label('Angaben korrigieren')->color('primary')->action(fn () => $this->replaceMountedAction('provideContact'))
: null,
($step = ActivityDetails::activity($this->record, (string) ($arguments['key'] ?? ''))?->action) !== null && $step !== 'provideContact'
? Action::make('doStep')->label('Diesen Schritt ausführen')->action(fn () => $this->replaceMountedAction($step))
: null,
])));
}
/**
* v0.11 data request: send the prepared question (or ask now although the case is set to asking by hand).
*/
private function approveDataRequestAction(): Action
{
return Action::make('approveDataRequest')
->label('Rückfrage an den Gast senden')
->icon(Heroicon::OutlinedPaperAirplane)
->visible(fn (): bool => in_array($this->record->openDataRequest()?->status, [DataRequest::DRAFT, DataRequest::MANUAL], true) && filled($this->record->guest?->email))
->modalHeading('Fehlende Angaben beim Gast anfragen')
->modalDescription(function (): string {
$request = $this->record->openDataRequest();
$state = $this->record->clarificationState();
return 'Der Gast erhält eine E-Mail mit einem persönlichen Link und wird gebeten um: '.implode(', ', CaseRequirements::labels((array) $request?->fields)).'. '
.match ($state['state']) {
'active' => 'Die Mail nennt die vorläufige Reservierung bis '.$state['until']->format('d.m.Y, H:i').' Uhr.',
'expired' => 'Die Mail sagt, dass die vorläufige Reservierung abgelaufen ist.',
default => $this->record->isBinding() ? 'Die Mail sagt, dass die Buchung verbindlich bleibt.' : 'Die Mail sagt, dass der Zeitraum noch nicht reserviert ist.',
}
.(RequestCaseData::mayGoOutAutomatically() ? '' : ' Hinweis: Der Text der Rückfrage ist noch eine Arbeitsfassung (So arbeite ich › Dokumente); mit „Senden“ bestätigen Sie ihn für diesen Vorgang.');
})
->modalSubmitActionLabel('Senden')
->action(function (RequestCaseData $requests): void {
$request = $this->record->openDataRequest();
$sent = $request !== null && $requests->approve($request);
$this->record->refresh();
$sent
? Notification::make()->title('Rückfrage gesendet')->success()->send()
: Notification::make()->title('Nicht gesendet')->body('Bitte die E-Mail-Adresse des Gastes prüfen – oder es fehlt inzwischen nichts mehr.')->danger()->send();
});
}
private function stopDataRequestAction(): Action
{
return Action::make('stopDataRequest')
->label('Rückfrage beenden')
->icon(Heroicon::OutlinedNoSymbol)
->color('gray')
->visible(fn (): bool => $this->record->openDataRequest() !== null)
->requiresConfirmation()
->modalDescription('Es gehen keine Erinnerungen und Folgefragen mehr hinaus. Die fehlenden Angaben tragen Sie dann selbst ein.')
->action(function (RequestCaseData $requests): void {
$requests->close($this->record->openDataRequest(), DataRequest::STOPPED, 'von Ihnen beendet');
$this->record->refresh();
Notification::make()->title('Rückfrage beendet')->success()->send();
});
}
private function requestContactAction(): Action
{
return Action::make('requestContact')
@@ -0,0 +1,60 @@
<?php
namespace App\Filament\Resources\Bookings\RelationManagers;
use App\Models\InboundMessage;
use Filament\Actions\Action;
use Filament\Infolists\Components\TextEntry;
use Filament\Resources\RelationManagers\RelationManager;
use Filament\Support\Icons\Heroicon;
use Filament\Tables\Columns\IconColumn;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;
use Illuminate\Support\HtmlString;
/**
* Communication log, incoming side (v0.11): every e-mail of the guest or the portal that the inbox assigned to this
* case, with what the evaluation found.
*/
class InboundMessagesRelationManager extends RelationManager
{
protected static string $relationship = 'inboundMessages';
protected static ?string $title = 'Eingegangene E-Mails';
public function isReadOnly(): bool
{
return true;
}
public function table(Table $table): Table
{
return $table
->recordTitleAttribute('subject')
->defaultSort('received_at', 'desc')
->emptyStateHeading('Noch keine eingegangenen E-Mails zu diesem Vorgang')
->description('Antworten und Nachrichten aus dem Postfach für die Gästekommunikation, die diesem Vorgang zugeordnet sind. Nicht zugeordnete Nachrichten stehen unter Verwaltung › Posteingang.')
->columns([
TextColumn::make('received_at')->label('Eingang')->dateTime('d.m.Y, H:i'),
TextColumn::make('from_address')->label('Von')->description(fn (InboundMessage $record): ?string => $record->from_name),
TextColumn::make('subject')->label('Betreff')->wrap(),
TextColumn::make('extraction_status')->label('Auswertung')->badge()->formatStateUsing(fn (?string $state): string => match ($state) {
'done' => 'ausgewertet',
'failed' => 'nicht möglich',
'disabled' => 'ohne KI',
default => 'ausstehend',
}),
IconColumn::make('test_mode')->label('Testbetrieb')->boolean()->trueIcon(Heroicon::OutlinedBeaker)->falseIcon(null),
])
->recordActions([
Action::make('read')->label('Lesen')->icon(Heroicon::OutlinedEye)
->modalHeading(fn (InboundMessage $record): string => (string) $record->subject)
->modalSubmitAction(false)->modalCancelActionLabel('Schließen')->modalWidth('3xl')
->schema([
TextEntry::make('found')->label('Erkannt')->state(fn (InboundMessage $record): string => collect([...(array) ($record->extraction['applied'] ?? []), ...(array) ($record->extraction['proposed'] ?? [])])
->map(fn (array $fact): string => $fact['field'].': „'.$fact['value'].'“')->implode(' · ') ?: '–'),
TextEntry::make('body_text')->label('Nachricht')->state(fn (InboundMessage $record): HtmlString => new HtmlString(nl2br(e((string) $record->body)))),
]),
]);
}
}
@@ -13,7 +13,7 @@ class MessagesRelationManager extends RelationManager
{
protected static string $relationship = 'messages';
protected static ?string $title = 'Mailverlauf';
protected static ?string $title = 'Gesendete E-Mails';
public function isReadOnly(): bool
{
@@ -7,6 +7,7 @@
use App\Models\Channel;
use App\Models\Extra;
use App\Models\Property;
use App\Support\Countries;
use App\Support\CurrentProperty;
use App\Support\Money;
use Filament\Forms\Components\DatePicker;
@@ -120,7 +121,7 @@ public static function configure(Schema $schema): Schema
Select::make('channel_id')
->label(fn (Get $get): string => $get('kind') === self::EXTERNAL ? 'Gebucht über' : 'Über ein Portal (optional)')
->placeholder('Direkt – kein Portal')
->options(fn (Get $get): array => Channel::query()->where('property_id', $get('property_id'))->orderBy('name')->pluck('name', 'id')->all())
->options(fn (Get $get): array => Channel::query()->portals()->where('property_id', $get('property_id'))->orderBy('name')->pluck('name', 'id')->all())
->required($is(self::EXTERNAL)),
TextInput::make('portal_reference')->label('Buchungsnummer im Portal')->maxLength(100)->visible($is(self::EXTERNAL)),
EuroInput::make('portal_total')
@@ -140,6 +141,7 @@ public static function configure(Schema $schema): Schema
TextInput::make('street')->label('Straße')->maxLength(255),
TextInput::make('postal_code')->label('PLZ')->maxLength(20),
TextInput::make('city')->label('Ort')->maxLength(255),
Select::make('country')->label('Land')->options(Countries::options())->placeholder('nicht bekannt'),
Toggle::make('guest_confirmed')->label('Der Gast hat die Buchung bereits per E-Mail bestätigt')->visible($is(self::EXTERNAL)),
]),
Section::make('Wie geht es weiter?')
@@ -50,7 +50,7 @@ public static function configure(Schema $schema): Schema
->columnSpan(2)
->schema([
Section::make('Ablauf')
->description('Was erledigt ist, was wartet und was noch kommt.')
->description('Was erledigt ist, was wartet und was noch kommt. Ein Klick auf einen Schritt zeigt, was dort geschah und woher die Angaben stammen.')
->schema([TextEntry::make('activities')->hiddenLabel()->state(fn (Booking $record): HtmlString => self::activities($record))->html()]),
Section::make('Preis und Zahlungen')
->schema([
@@ -151,7 +151,7 @@ private static function nextStep(Booking $booking): HtmlString
default => 'Nichts zu tun.',
};
$color = $next?->state === ActivityState::Problem ? '#dc2626' : ($next !== null ? '#b45309' : '#15803d');
$detail = $next?->detail ?? $waiting?->detail;
$detail = $next !== null ? $next->detail : $waiting?->detail;
$mode = $automatic
? 'Dieser Vorgang läuft automatisch weiter, sobald alle Angaben da sind.'.(($blockers = self::blockers($booking)) !== [] ? ' Es fehlt: '.e(implode(' ', $blockers)) : '')
: 'Sie geben jeden Schritt selbst frei. Der Knopf oben rechts führt zum nächsten Schritt.';
@@ -217,7 +217,8 @@ private static function activities(Booking $booking): HtmlString
$color = $colors[$activity->state->getColor()];
$strong = $activity->state->needsAction() ? 'font-weight:700' : '';
return '<li style="display:flex;gap:.75rem;padding:.45rem 0;border-bottom:1px solid rgba(128,128,128,.2)">'
// A click opens what lies behind the step (ViewBooking::activityDetailsAction).
return '<li style="display:flex;gap:.75rem;padding:.45rem 0;border-bottom:1px solid rgba(128,128,128,.2);cursor:pointer" title="Einzelheiten ansehen" wire:click="mountAction(&#039;activityDetails&#039;, { key: &#039;'.e($activity->key).'&#039; })">'
.'<span style="width:1.4rem;text-align:center;font-weight:700;color:'.$color.'">'.$activity->state->icon().'</span>'
.'<span style="flex:1;'.$strong.'">'.e($activity->label)
.($activity->detail ? ' <span style="font-weight:400;color:#6b7280">· '.e($activity->detail).'</span>' : '')
@@ -91,7 +91,7 @@ public static function configure(Table $table, ?int $guestId = null): Table
...collect(BookingStatus::cases())->mapWithKeys(fn (BookingStatus $status): array => [$status->value => $status->getLabel()])->all(),
'imported' => 'Im Portalkalender geführt', 'archived' => 'Nicht mehr im Kalenderfeed',
]),
SelectFilter::make('channel')->label('Buchungskanal')->options(fn (): array => Channel::query()->orderBy('name')->pluck('name', 'id')->all()),
SelectFilter::make('channel')->label('Buchungskanal')->options(fn (): array => Channel::query()->portals()->orderBy('name')->pluck('name', 'id')->all()),
Filter::make('period')->label('Anreise im Zeitraum')->schema([
DatePicker::make('arrival_from')->label('Anreise ab'),
DatePicker::make('arrival_until')->label('Anreise bis'),
@@ -29,11 +29,11 @@ class ChannelResource extends Resource
protected static string|UnitEnum|null $navigationGroup = 'Einrichtung';
protected static ?string $navigationLabel = 'Kalenderabgleich (iCal)';
protected static ?string $navigationLabel = 'Kanäle';
protected static ?string $modelLabel = 'iCal-Verbindung';
protected static ?string $modelLabel = 'Kanal';
protected static ?string $pluralModelLabel = 'Kalenderabgleich (iCal)';
protected static ?string $pluralModelLabel = 'Kanäle (Webseite, Portale, iCal)';
protected static ?int $navigationSort = 4;
@@ -6,6 +6,7 @@
use App\Actions\ConfigureChannel;
use App\Channels\ChannelSyncException;
use App\Filament\Resources\Channels\ChannelResource;
use App\Models\Channel;
use Filament\Actions\Action;
use Filament\Notifications\Notification;
use Filament\Resources\Pages\EditRecord;
@@ -18,8 +19,8 @@ class EditChannel extends EditRecord
protected function getHeaderActions(): array
{
return [
Action::make('rules')->label('Regeln & Exportfelder')->url(fn (): string => ChannelResource::getUrl('rules', ['record' => $this->record])),
Action::make('analyze')->label('Kalender analysieren')->action(function (AnalyzeChannelCalendar $analyze): void {
Action::make('rules')->label('Regeln & Exportfelder')->url(fn (): string => ChannelResource::getUrl('rules', ['record' => $this->record]))->visible(fn (): bool => $this->record->isPortal()),
Action::make('analyze')->label('Kalender analysieren')->visible(fn (): bool => $this->record->isPortal())->action(function (AnalyzeChannelCalendar $analyze): void {
try {
$analyze->handle($this->record);
$this->redirect(ChannelResource::getUrl('rules', ['record' => $this->record]));
@@ -37,6 +38,13 @@ protected function mutateFormDataBeforeFill(array $data): array
protected function handleRecordUpdate(Model $record, array $data): Model
{
// The own website's entry only keeps its settings; there is no connection to configure.
if ($record instanceof Channel && $record->isWebsite()) {
$record->update(['process_overrides' => $data['process_overrides'] ?? []]);
return $record;
}
return app(ConfigureChannel::class)->handle($record->property, $data, $record);
}
@@ -3,20 +3,44 @@
namespace App\Filament\Resources\Channels\Pages;
use App\Filament\Concerns\ListsCurrentProperty;
use App\Filament\Pages\HandlingSettings;
use App\Filament\Resources\Channels\ChannelResource;
use App\Models\Channel;
use App\Models\Property;
use Filament\Actions\Action;
use Filament\Actions\CreateAction;
use Filament\Resources\Pages\ListRecords;
use Filament\Support\Icons\Heroicon;
/**
* The channel manager (v0.11, E-037): the own website and every portal of the landlord in one list. The landlord's
* defaults for all channels stay on "So arbeite ich"; each channel only keeps its deviations.
*/
class ListChannels extends ListRecords
{
use ListsCurrentProperty;
protected static string $resource = ChannelResource::class;
public function mount(): void
{
parent::mount();
// Every property has its website entry (created by the migration; new properties get it here).
Property::query()->get()->each(fn (Property $property): Channel => Channel::websiteOf($property));
}
public function getSubheading(): ?string
{
return 'Alle Eingangskanäle an einer Stelle: Ihre eigene Webseite und die Portale. Was für alle Kanäle gilt, stellen Sie unter „Ihre Standards“ ein; hier steht nur, was ein Kanal anders macht.';
}
protected function getHeaderActions(): array
{
return [
CreateAction::make()->label('iCal-Verbindung anlegen'),
Action::make('defaults')->label('Ihre Standards (alle Kanäle)')->icon(Heroicon::OutlinedAdjustmentsHorizontal)->color('gray')
->url(fn (): string => HandlingSettings::getUrl()),
CreateAction::make()->label('Portal (iCal-Verbindung) anlegen'),
];
}
}
@@ -39,77 +39,110 @@ public static function configure(Schema $schema, bool $selectProperty = false):
->options(fn (): array => Property::query()->orderBy('name')->pluck('name', 'id')->all())
->default(fn (): ?int => app(CurrentProperty::class)->id())
->disabled(fn (?Channel $record): bool => $record !== null)->dehydrated()->columnSpanFull()] : []),
TextEntry::make('export_url')
->label('Eigener iCal-Exportlink')
->state(fn (?Channel $record): ?string => $record?->exportUrl())
->visible(fn (?Channel $record): bool => $record?->exists ?? false)
->copyable()
->copyMessage('Exportlink kopiert')
->wrap()
->extraAttributes(['style' => 'overflow-wrap:anywhere'])
->columnSpanFull(),
TextInput::make('name')
->label('Name der Kalenderverbindung')
->placeholder('z. B. FeWo-direkt')
->required()
->maxLength(100),
Select::make('status')->label('Kanalstatus')->options(ChannelStatus::class)->default(ChannelStatus::Setup)->required(),
Select::make('booking_model')->label('Was kommt über dieses Portal?')->options(ChannelBookingModel::class)->default(ChannelBookingModel::Mixed)->required()
->helperText('„Portalbuchung“ und „Gemischt“ gelten als Sofortbuchung: automatische Angebote für diese Wohnung warten, bis das Portal unseren Kalender abgerufen hat. „Vermittlung / Anfrage“: keine Sofortbuchung.'),
Select::make('case_intake')
->label('Erkannte Buchungen automatisch als Vorgang übernehmen?')
->options(CaseIntakeMode::class)
->default(CaseIntakeMode::Off)
->required()
->helperText('Zuerst „Beobachten“: Dann entsteht nichts, aber das Eingangsprotokoll (Expertenansicht) zeigt, welche Vorgänge entstanden wären. Unklare Belegungen und Meldungen zu gebuchten Vorgängen erscheinen unter „Zu erledigen“. Unterlagen gehen nie ohne Ihre Freigabe hinaus.')
->columnSpanFull(),
...self::processSections(),
Select::make('connector')
->label('Kalenderanbindung')
->helperText('Diese Verbindung gleicht Belegungszeiträume über iCal ab. Weitere Portalfunktionen benötigen eine eigene Anbindung.')
->options($registry->options())
->default('ical')
->live()
->required(),
Group::make()
->columns(2)
->columnSpanFull()
->schema(fn (Get $get): array => filled($get('connector')) ? $registry->connectors()[$get('connector')]::settingsSchema() : []),
Toggle::make('import_enabled')->label('Import aktiviert')->default(false)
->helperText('Abruf durch FewoPortal alle fünf Minuten, sofern der Kanal aktiv ist.'),
Toggle::make('export_enabled')->label('Export aktiviert')->default(false)
->helperText('Ausgeschaltet bleibt der letzte gültige Export eingefroren erreichbar. Ohne Stand: HTTP 503, kein leerer Kalender.'),
Select::make('export_mode')->label('Exportmodus')->options(ChannelExportMode::class)->default(ChannelExportMode::Test)->required()
->helperText('Testbetrieb exportiert keine Fremdbelegungen und gewährleistet keine vollständige kanalübergreifende Sperrung. Regulär nur nach bewusster Freigabe wählen.')
->columnSpanFull(),
TextInput::make('external_poll_minutes')->label('Erwarteter externer Abrufabstand (Minuten)')
->integer()->minValue(1)->maxValue(43200)
->helperText('Nur eine Annahme zum Portal; verändert weder unseren Abruf noch bestätigt sie eine Übernahme.'),
Select::make('echo_behavior')->label('Beobachtetes Rückkopplungsverhalten')->options(ChannelEchoBehavior::class)->default(ChannelEchoBehavior::Unverified)->required()->columnSpanFull()
->helperText('Bei Weitergabe mit neuen UIDs bleiben neue Importereignisse bis zur persönlichen Klärung vom Export ausgeschlossen. Sie sperren intern weiterhin.'),
Textarea::make('echo_notes')->label('Nachweis / Beobachtung zum Rückkopplungsverhalten')->maxLength(4000)->columnSpanFull(),
DateTimePicker::make('portal_verified_at')->label('Tatsächliche Übernahme im Portal zuletzt persönlich geprüft')->seconds(false)
->helperText('Nur nach Sichtkontrolle im Portal eintragen. Wird durch einen Feedabruf nicht automatisch gesetzt.'),
Textarea::make('operating_notes')->label('Zusätzliche Anforderungen dieses Portals')->maxLength(4000)->columnSpanFull()
->helperText('Zum Beispiel eine zusätzliche Bestätigung, dass der Belegungskalender gepflegt ist.'),
TextInput::make('settings.email_senders')
->label('Absender der Buchungs-E-Mails (Schnellerkennung)')
->helperText('Komma-getrennt, z. B. „fewo-direkt.de, vrbo.com“. Buchungsbestätigungen dieser Absender werden sofort gesperrt.')
->maxLength(500)
->columnSpanFull(),
Toggle::make('requires_manual_blocking')
->label('Zusätzlich von Hand sperren (Sofortbuchung)')
->helperText('Bei jeder Belegung über andere Wege entsteht eine Aufgabe „Im Portal sperren“ – für Portale, die unseren Kalender zu selten abholen.')
->live()
->columnSpanFull(),
TextInput::make('manage_url')
->label('Link zum Kalender im Vermieterbereich')
->url()
->maxLength(2048)
->visible(fn (Get $get): bool => (bool) $get('requires_manual_blocking'))
->columnSpanFull(),
->visible(fn (?Channel $record): bool => ! ($record?->isWebsite() ?? false))
->schema([
TextEntry::make('export_url')
->label('Eigener iCal-Exportlink')
->state(fn (?Channel $record): ?string => $record?->exportUrl())
->visible(fn (?Channel $record): bool => $record?->exists ?? false)
->copyable()
->copyMessage('Exportlink kopiert')
->wrap()
->extraAttributes(['style' => 'overflow-wrap:anywhere'])
->columnSpanFull(),
TextInput::make('name')
->label('Name der Kalenderverbindung')
->placeholder('z. B. FeWo-direkt')
->required()
->maxLength(100),
Select::make('status')->label('Kanalstatus')->options(ChannelStatus::class)->default(ChannelStatus::Setup)->required(),
Select::make('booking_model')->label('Was kommt über dieses Portal?')->options(ChannelBookingModel::class)->default(ChannelBookingModel::Mixed)->required()
->helperText('„Portalbuchung“ und „Gemischt“ gelten als Sofortbuchung: automatische Angebote für diese Wohnung warten, bis das Portal unseren Kalender abgerufen hat. „Vermittlung / Anfrage“: keine Sofortbuchung.'),
Select::make('case_intake')
->label('Erkannte Buchungen automatisch als Vorgang übernehmen?')
->options(CaseIntakeMode::class)
->default(CaseIntakeMode::Off)
->required()
->helperText('Zuerst „Beobachten“: Dann entsteht nichts, aber das Eingangsprotokoll (Expertenansicht) zeigt, welche Vorgänge entstanden wären. Unklare Belegungen und Meldungen zu gebuchten Vorgängen erscheinen unter „Zu erledigen“. Unterlagen gehen nie ohne Ihre Freigabe hinaus.')
->columnSpanFull(),
...self::processSections(),
Select::make('connector')
->label('Kalenderanbindung')
->helperText('Diese Verbindung gleicht Belegungszeiträume über iCal ab. Weitere Portalfunktionen benötigen eine eigene Anbindung.')
->options($registry->options())
->default('ical')
->live()
->required(),
Group::make()
->columnSpanFull()
->schema(fn (Get $get): array => isset($registry->connectors()[$get('connector')]) ? $registry->connectors()[$get('connector')]::settingsSchema() : []),
Toggle::make('import_enabled')->label('Import aktiviert')->default(false)
->helperText('Abruf durch FewoPortal alle fünf Minuten, sofern der Kanal aktiv ist.'),
Toggle::make('export_enabled')->label('Export aktiviert')->default(false)
->helperText('Ausgeschaltet bleibt der letzte gültige Export eingefroren erreichbar. Ohne Stand: HTTP 503, kein leerer Kalender.'),
Select::make('export_mode')->label('Exportmodus')->options(ChannelExportMode::class)->default(ChannelExportMode::Test)->required()
->helperText('Testbetrieb exportiert keine Fremdbelegungen und gewährleistet keine vollständige kanalübergreifende Sperrung. Regulär nur nach bewusster Freigabe wählen.')
->columnSpanFull(),
TextInput::make('external_poll_minutes')->label('Erwarteter externer Abrufabstand (Minuten)')
->integer()->minValue(1)->maxValue(43200)
->helperText('Nur eine Annahme zum Portal; verändert weder unseren Abruf noch bestätigt sie eine Übernahme.'),
Select::make('echo_behavior')->label('Beobachtetes Rückkopplungsverhalten')->options(ChannelEchoBehavior::class)->default(ChannelEchoBehavior::Unverified)->required()->columnSpanFull()
->helperText('Bei Weitergabe mit neuen UIDs bleiben neue Importereignisse bis zur persönlichen Klärung vom Export ausgeschlossen. Sie sperren intern weiterhin.'),
Textarea::make('echo_notes')->label('Nachweis / Beobachtung zum Rückkopplungsverhalten')->maxLength(4000)->columnSpanFull(),
DateTimePicker::make('portal_verified_at')->label('Tatsächliche Übernahme im Portal zuletzt persönlich geprüft')->seconds(false)
->helperText('Nur nach Sichtkontrolle im Portal eintragen. Wird durch einen Feedabruf nicht automatisch gesetzt.'),
Textarea::make('operating_notes')->label('Zusätzliche Anforderungen dieses Portals')->maxLength(4000)->columnSpanFull()
->helperText('Zum Beispiel eine zusätzliche Bestätigung, dass der Belegungskalender gepflegt ist.'),
TextInput::make('settings.email_senders')
->label('Absender der Buchungs-E-Mails (Schnellerkennung)')
->helperText('Komma-getrennt, z. B. „fewo-direkt.de, vrbo.com“. Buchungsbestätigungen dieser Absender werden sofort gesperrt.')
->maxLength(500)
->columnSpanFull(),
Toggle::make('requires_manual_blocking')
->label('Zusätzlich von Hand sperren (Sofortbuchung)')
->helperText('Bei jeder Belegung über andere Wege entsteht eine Aufgabe „Im Portal sperren“ – für Portale, die unseren Kalender zu selten abholen.')
->live()
->columnSpanFull(),
TextInput::make('manage_url')
->label('Link zum Kalender im Vermieterbereich')
->url()
->maxLength(2048)
->visible(fn (Get $get): bool => (bool) $get('requires_manual_blocking'))
->columnSpanFull(),
]),
...self::websiteSections(),
]);
}
/**
* The own website's entry (v0.11 channel manager): only the settings of requests from the website. Empty fields
* follow the defaults (System › So arbeite ich); there is no calendar connection.
*
* @return list<Section>
*/
private static function websiteSections(): array
{
$defaults = (array) (Settings::tenant()?->process_defaults ?? []);
$inherited = function (ProcessSetting $setting) use ($defaults): string {
$value = $setting->normalize($defaults[$setting->value] ?? null) ?? $setting->default();
return $setting === ProcessSetting::ContractTemplate ? 'Vorlage der Wohnung' : $setting->describe($value);
};
$settings = array_values(array_filter(ProcessSetting::cases(), fn (ProcessSetting $setting): bool => in_array(IntakeKind::Inquiry, $setting->channelIntakes(), true)));
return [
Section::make('Anfragen über die eigene Webseite')
->description('Nur ausfüllen, was für Anfragen über Ihre Webseite anders sein soll als in Ihren Standardeinstellungen (System › So arbeite ich). Telefon- und E-Mail-Anfragen folgen weiter den Standardeinstellungen.')
->columns(2)
->columnSpanFull()
->visible(fn (?Channel $record): bool => $record?->isWebsite() ?? false)
->schema(ProcessSettingFields::make('process_overrides.inquiry.', $settings, $inherited)),
];
}
/**
* What a contract template brings along, shown under the template choice.
*/
@@ -127,7 +160,7 @@ private static function processSections(): array
return $setting === ProcessSetting::ContractTemplate ? 'Vorlage der Wohnung' : $setting->describe($value);
};
$settingsFor = fn (IntakeKind $intake): array => array_values(array_filter(ProcessSetting::cases(), fn (ProcessSetting $setting): bool => in_array($intake, $setting->channelIntakes(), true)));
$settingsFor = fn (IntakeKind $intake): array => array_values(array_filter(ProcessSetting::cases(), fn (ProcessSetting $setting): bool => $setting !== ProcessSetting::FormRequiresAddress && in_array($intake, $setting->channelIntakes(), true)));
return [
Section::make('Anfragen über dieses Portal')
@@ -46,6 +46,7 @@ public static function configure(Table $table, ?Property $owner = null): Table
TextColumn::make('property.name')->label('Wohnung')->visible($owner === null)->searchable()->color('gray')->wrap(),
TextColumn::make('channel_state')->label('Status')->badge()->wrap()
->state(fn (Channel $record): string => match (true) {
$record->isWebsite() => 'Eigene Webseite – nur Einstellungen',
! $record->importsOccupations() => $record->status->getLabel(),
$record->last_error !== null => 'Importfehler',
$record->last_success_at === null => 'Erster Import ausstehend',
@@ -53,6 +54,7 @@ public static function configure(Table $table, ?Property $owner = null): Table
default => $record->status->getLabel(),
})
->color(fn (Channel $record): string => match (true) {
$record->isWebsite() => 'info',
! $record->is_active => 'gray',
! $record->importsOccupations() => 'success',
$record->last_error !== null => 'danger',
@@ -62,12 +64,12 @@ public static function configure(Table $table, ?Property $owner = null): Table
})
->description(fn (Channel $record): ?string => $record->review_count || count($record->sync_warnings ?? []) ? 'Prüffälle: '.$record->review_count.' · Hinweise: '.count($record->sync_warnings ?? []) : null)
->tooltip(fn (Channel $record): ?string => $record->last_error),
TextColumn::make('directions')->label('Richtungen')->color('gray')->wrap()
TextColumn::make('directions')->label('Richtungen')->color('gray')->wrap()->hidden(fn (?Channel $record): bool => $record?->isWebsite() ?? false)
->state(fn (Channel $record): string => ($record->importsOccupations() ? 'Import aktiv' : 'Import aus').' · '.($record->exportsOccupations() ? 'Export aktiv' : ($record->export_snapshot_at ? 'Export eingefroren' : 'Export aus'))),
TextColumn::make('last_sync')->label('Letzter Sync-Lauf')->wrap()
TextColumn::make('last_sync')->label('Letzter Sync-Lauf')->wrap()->hidden(fn (?Channel $record): bool => $record?->isWebsite() ?? false)
->state(fn (Channel $record): string => 'Letzter Sync: '.($record->last_synced_at?->format('d.m.Y H:i') ?? 'noch kein Lauf'))
->description(fn (Channel $record): ?string => $record->last_error !== null ? 'Letzter Lauf mit Fehler' : null),
TextColumn::make('last_export_request')->label('Letzter Kalenderabruf')->wrap()->color('gray')
TextColumn::make('last_export_request')->label('Letzter Kalenderabruf')->wrap()->color('gray')->hidden(fn (?Channel $record): bool => $record?->isWebsite() ?? false)
->state(fn (Channel $record): string => 'Letzter Abruf: '.($record->last_export_requested_at?->format('d.m.Y H:i') ?? 'noch keiner'))
->tooltip('Empfangener Aufruf dieses Kanalfeeds. Client und tatsächliche Übernahme im Portal sind damit nicht bestätigt.'),
])->space(2),
@@ -78,7 +80,7 @@ public static function configure(Table $table, ?Property $owner = null): Table
->successNotificationTitle('iCal-Verbindung angelegt – Exportlink automatisch erzeugt'),
] : [])
->recordActions([
Action::make('exportLink')->label('Exportlink')->icon(Heroicon::OutlinedLink)->button()
Action::make('exportLink')->label('Exportlink')->icon(Heroicon::OutlinedLink)->button()->visible(fn (Channel $record): bool => $record->isPortal())
->modalDescription('Diese Adresse erlaubt den Kalenderabruf. Nur dem vorgesehenen Portal geben. Ein Abruf beweist keine tatsächliche Übernahme.')
->schema([
TextEntry::make('export_url')->label('Vertrauliche Kalenderadresse')->state(fn (Channel $record): string => $record->exportUrl())->copyable()->wrap()->extraAttributes(['style' => 'overflow-wrap:anywhere']),
@@ -162,7 +164,7 @@ public static function configure(Table $table, ?Property $owner = null): Table
TextEntry::make('warnings'),
]),
]),
])->label('Weitere Aktionen')->icon(Heroicon::OutlinedEllipsisVertical),
])->label('Weitere Aktionen')->icon(Heroicon::OutlinedEllipsisVertical)->visible(fn (Channel $record): bool => $record->isPortal()),
]);
}
}
@@ -68,7 +68,7 @@ public static function form(Schema $schema): Schema
->label('Zusatzleistung / Portal')
->options(fn (Get $get): array => match ($get('condition_type')) {
ContractAnnex::EXTRA => Extra::query()->orderBy('name')->pluck('name', 'id')->all(),
ContractAnnex::CHANNEL => Channel::query()->orderBy('name')->pluck('name', 'id')->all(),
ContractAnnex::CHANNEL => Channel::query()->portals()->orderBy('name')->pluck('name', 'id')->all(),
default => [],
})
->visible(fn (Get $get): bool => in_array($get('condition_type'), [ContractAnnex::EXTRA, ContractAnnex::CHANNEL], true))
@@ -0,0 +1,253 @@
<?php
namespace App\Filament\Resources\InboundMessages;
use App\Actions\ContributeCaseFacts;
use App\Actions\CreateReservation;
use App\Actions\ReceiveInboundMessage;
use App\Actions\RequestCaseData;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\FactSource;
use App\Exceptions\ReservationException;
use App\Filament\Concerns\FollowsAdminMode;
use App\Filament\Resources\Bookings\BookingResource;
use App\Filament\Resources\InboundMessages\Pages\ListInboundMessages;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\InboundMessage;
use App\Models\Property;
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\CaseLog;
use App\Process\CaseRequirements;
use BackedEnum;
use Carbon\CarbonImmutable;
use Filament\Actions\Action;
use Filament\Actions\ActionGroup;
use Filament\Forms\Components\CheckboxList;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Infolists\Components\TextEntry;
use Filament\Notifications\Notification;
use Filament\Resources\Resource;
use Filament\Support\Icons\Heroicon;
use Filament\Tables\Columns\IconColumn;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\HtmlString;
use UnitEnum;
/**
* The inbox of v0.11 (CH-06, "Kommunikations-Klärungsansicht"): messages of the guest communication mailbox, with
* hints from known senders. The landlord assigns a message to a case, makes a new request out of it, or ignores it.
* Nothing here changes a booking by itself.
*/
class InboundMessageResource extends Resource
{
use FollowsAdminMode;
protected static ?string $model = InboundMessage::class;
protected static string|BackedEnum|null $navigationIcon = Heroicon::OutlinedInboxArrowDown;
protected static string|UnitEnum|null $navigationGroup = 'Verwaltung';
protected static ?string $navigationLabel = 'Posteingang';
protected static ?string $modelLabel = 'Nachricht';
protected static ?string $pluralModelLabel = 'Posteingang';
protected static ?int $navigationSort = 7;
public static function canCreate(): bool
{
return false;
}
public static function getNavigationBadge(): ?string
{
$open = InboundMessage::query()->where('status', InboundMessage::NEEDS_REVIEW)->count();
return $open > 0 ? (string) $open : null;
}
public static function getNavigationBadgeColor(): string
{
return 'warning';
}
public static function table(Table $table): Table
{
return $table
->defaultSort('received_at', 'desc')
->emptyStateHeading('Keine Nachrichten')
->emptyStateDescription('Sobald ein Postfach im Modus „Alle Nachrichten“ eingerichtet ist (System › Betrieb), erscheinen Gast-Mails hier.')
->columns([
TextColumn::make('received_at')->label('Eingang')->dateTime('d.m.Y H:i')->sortable(),
TextColumn::make('from_address')->label('Von')->description(fn (InboundMessage $record): ?string => $record->from_name)->searchable(),
TextColumn::make('subject')->label('Betreff')->wrap()->searchable(),
TextColumn::make('status')->label('Stand')->badge()->formatStateUsing(fn (InboundMessage $record): string => $record->statusLabel())
->color(fn (string $state): string => match ($state) {
InboundMessage::NEEDS_REVIEW => 'warning',
InboundMessage::ASSIGNED => 'info',
InboundMessage::PROCESSED, InboundMessage::PORTAL => 'success',
default => 'gray',
}),
TextColumn::make('booking.reference')->label('Vorgang')->url(fn (InboundMessage $record): ?string => $record->booking ? BookingResource::getUrl('view', ['record' => $record->booking]) : null),
IconColumn::make('test_mode')->label('Testbetrieb')->boolean()->trueIcon(Heroicon::OutlinedBeaker)->falseIcon(null)->tooltip('Im Testbetrieb eingegangen'),
])
->filters([
SelectFilter::make('status')->label('Stand')->options([
InboundMessage::NEEDS_REVIEW => 'zu klären', InboundMessage::ASSIGNED => 'zugeordnet', InboundMessage::PROCESSED => 'erledigt',
InboundMessage::PORTAL => 'Portal-Mail', InboundMessage::IGNORED => 'ignoriert',
]),
])
->recordActions([
Action::make('read')->label('Lesen')->icon(Heroicon::OutlinedEye)->button()
->modalHeading(fn (InboundMessage $record): string => (string) $record->subject)
->modalSubmitAction(false)->modalCancelActionLabel('Schließen')->modalWidth('3xl')
->schema([
TextEntry::make('from')->label('Von')->state(fn (InboundMessage $record): string => trim(($record->from_name ? $record->from_name.' · ' : '').$record->from_address)),
TextEntry::make('hints_text')->label('Hinweise')->state(fn (InboundMessage $record): string => collect((array) $record->hints)->map(fn (array $hint): string => $hint['reference'].': '.$hint['why'])->implode(' · ') ?: 'keine')
->visible(fn (InboundMessage $record): bool => $record->status === InboundMessage::NEEDS_REVIEW),
TextEntry::make('proposals_text')->label('Erkannte Angaben (KI-Vorschläge)')
->state(fn (InboundMessage $record): HtmlString => new HtmlString(collect((array) ($record->extraction['proposed'] ?? []))
->map(fn (array $fact): string => e(CaseRequirements::label($fact['field']).': „'.$fact['value'].'“').($fact['problems'] !== [] ? ' <em>('.e(implode(', ', $fact['problems'])).')</em>' : ' <em>(unsicher)</em>'))
->implode('<br>') ?: '–'))
->visible(fn (InboundMessage $record): bool => ($record->extraction['proposed'] ?? []) !== []),
TextEntry::make('applied_text')->label('Automatisch übernommen')
->state(fn (InboundMessage $record): string => collect((array) ($record->extraction['applied'] ?? []))->map(fn (array $fact): string => CaseRequirements::label($fact['field']).': „'.$fact['value'].'“')->implode(' · '))
->visible(fn (InboundMessage $record): bool => ($record->extraction['applied'] ?? []) !== []),
TextEntry::make('body_text')->label('Nachricht')->state(fn (InboundMessage $record): HtmlString => new HtmlString(nl2br(e((string) $record->body)))),
]),
Action::make('assign')->label('Vorgang zuordnen')->icon(Heroicon::OutlinedLink)
->visible(fn (InboundMessage $record): bool => $record->status === InboundMessage::NEEDS_REVIEW)
->schema([
Select::make('booking_id')->label('Vorgang')->required()->searchable()
->options(fn (InboundMessage $record): array => self::caseOptions($record)),
])
->action(function (InboundMessage $record, array $data, RequestCaseData $requests): void {
$booking = Booking::query()->findOrFail($data['booking_id']);
$record->update(['status' => InboundMessage::ASSIGNED, 'booking_id' => $booking->id, 'match_reason' => 'landlord']);
CaseLog::record($booking, 'mail_in', 'E-Mail von Ihnen zugeordnet: '.$record->subject);
$requests->replyReceived($booking);
BookingTask::openOnce($booking, BookingTaskKind::InboundReview, 'm'.$record->id, ['due_on' => today(), 'note' => '„'.mb_substr((string) $record->subject, 0, 120).'“ – im Posteingang ansehen.']);
app(ReceiveInboundMessage::class)->evaluate($record);
Notification::make()->title('Zugeordnet')->body(self::evaluationSummary($record->fresh()))->success()->send();
}),
Action::make('evaluateAgain')->label('Erneut auswerten')->icon(Heroicon::OutlinedArrowPath)->color('gray')
->visible(fn (InboundMessage $record): bool => $record->booking_id !== null && in_array($record->extraction_status, ['failed', 'disabled'], true))
->action(function (InboundMessage $record): void {
$record->update(['extraction_status' => null]);
app(ReceiveInboundMessage::class)->evaluate($record);
Notification::make()->title('Ausgewertet')->body(self::evaluationSummary($record->fresh()))->send();
}),
Action::make('createInquiry')->label('Als neue Anfrage anlegen')->icon(Heroicon::OutlinedPlus)
->visible(fn (InboundMessage $record): bool => $record->status === InboundMessage::NEEDS_REVIEW)
->modalDescription('Es entsteht eine unverbindliche Anfrage wie über die Webseite; der Gast erhält die übliche Eingangsbestätigung bzw. Rückfrage. Termine und Personenzahl bitte aus der Nachricht übernehmen.')
->fillForm(fn (InboundMessage $record): array => [
'property_id' => Property::query()->orderBy('id')->value('id'),
'email' => $record->from_address,
'first_name' => str($record->from_name ?? '')->before(' ')->toString(),
'last_name' => str($record->from_name ?? '')->after(' ')->toString(),
'guests' => 2,
])
->schema([
Select::make('property_id')->label('Wohnung')->options(fn (): array => Property::query()->orderBy('name')->pluck('name', 'id')->all())->required(),
DatePicker::make('arrival')->label('Anreise')->required(),
DatePicker::make('departure')->label('Abreise')->required()->after('arrival'),
TextInput::make('guests')->label('Personen')->integer()->minValue(1)->required(),
TextInput::make('first_name')->label('Vorname')->required(),
TextInput::make('last_name')->label('Nachname')->required(),
TextInput::make('email')->label('E-Mail')->email()->required(),
])
->action(function (InboundMessage $record, array $data, CreateReservation $create): void {
try {
$booking = $create->handle(Property::query()->findOrFail($data['property_id']), new StayRequest(CarbonImmutable::parse($data['arrival']), CarbonImmutable::parse($data['departure']), (int) $data['guests']),
['first_name' => $data['first_name'], 'last_name' => $data['last_name'], 'email' => $data['email']], mb_substr((string) $record->body, 0, 2000), source: 'email');
} catch (QuoteException|ReservationException $exception) {
Notification::make()->title('Nicht möglich')->body($exception->getMessage())->danger()->send();
return;
}
$record->update(['status' => InboundMessage::PROCESSED, 'booking_id' => $booking->id, 'match_reason' => 'new_request', 'processed_at' => now()]);
Notification::make()->title('Anfrage '.$booking->reference.' angelegt')->success()->send();
}),
Action::make('applyProposals')->label('Vorschläge übernehmen')->icon(Heroicon::OutlinedCheckBadge)
->visible(fn (InboundMessage $record): bool => $record->booking_id !== null && ($record->extraction['proposed'] ?? []) !== [])
->modalDescription('Nur übernehmen, was Sie in der Nachricht selbst geprüft haben. Zeitraum und Personenzahl ändern Sie über „Buchung ändern“ bzw. ein neues Angebot.')
->schema([
CheckboxList::make('fields')->label('Angaben')->required()
->options(fn (InboundMessage $record): array => collect((array) ($record->extraction['proposed'] ?? []))
->reject(fn (array $fact): bool => in_array($fact['field'], ContributeCaseFacts::STAY_FIELDS, true))
->mapWithKeys(fn (array $fact): array => [$fact['field'] => CaseRequirements::label($fact['field']).': „'.$fact['value'].'“'])->all()),
])
->action(function (InboundMessage $record, array $data, ContributeCaseFacts $facts): void {
$chosen = collect((array) ($record->extraction['proposed'] ?? []))->whereIn('field', $data['fields']);
$result = $facts->handle($record->booking, $chosen->mapWithKeys(fn (array $fact): array => [$fact['field'] => $fact['value']])->all(), FactSource::Landlord, [
'inbound_message_id' => $record->id,
'reference' => 'message-landlord:'.$record->id,
'evidence' => $chosen->mapWithKeys(fn (array $fact): array => [$fact['field'] => $fact['evidence']])->all(),
]);
$record->update(['extraction' => [...(array) $record->extraction, 'proposed' => collect((array) ($record->extraction['proposed'] ?? []))->whereNotIn('field', $data['fields'])->values()->all()]]);
Notification::make()->title('Übernommen')->body($result->summary())->success()->send();
}),
ActionGroup::make([
Action::make('done')->label('Als erledigt markieren')->icon(Heroicon::OutlinedCheck)
->visible(fn (InboundMessage $record): bool => $record->status === InboundMessage::ASSIGNED)
->action(function (InboundMessage $record): void {
$record->update(['status' => InboundMessage::PROCESSED, 'processed_at' => now()]);
BookingTask::query()->where('booking_id', $record->booking_id)->where('kind', BookingTaskKind::InboundReview)->where('subject', 'm'.$record->id)->where('status', BookingTaskStatus::Open)
->get()->each(fn (BookingTask $task): bool => $task->forceFill(['status' => BookingTaskStatus::Done, 'completed_at' => now(), 'completed_by' => auth()->user()?->name])->save());
}),
Action::make('ignore')->label('Ignorieren')->icon(Heroicon::OutlinedEyeSlash)->color('gray')
->visible(fn (InboundMessage $record): bool => $record->status === InboundMessage::NEEDS_REVIEW)
->action(fn (InboundMessage $record) => $record->update(['status' => InboundMessage::IGNORED, 'processed_at' => now()])),
]),
]);
}
/**
* What the evaluation of a message did, in one sentence.
*/
public static function evaluationSummary(InboundMessage $message): string
{
$applied = collect((array) ($message->extraction['applied'] ?? []))->map(fn (array $fact): string => CaseRequirements::label($fact['field']))->implode(', ');
$proposed = count((array) ($message->extraction['proposed'] ?? []));
return match ($message->extraction_status) {
'done' => ($applied !== '' ? 'Übernommen: '.$applied.'.' : 'Keine Angaben automatisch übernommen.').($proposed > 0 ? ' '.$proposed.' Vorschlag/Vorschläge zu prüfen.' : ''),
'disabled' => 'Keine automatische Auswertung (System › KI-Anbindung nicht eingerichtet oder abgelehnt).',
'failed' => 'Die automatische Auswertung war nicht möglich: '.($message->extraction['error'] ?? 'unbekannter Fehler'),
default => 'Wird ausgewertet.',
};
}
/**
* Cases to assign a message to: the hints first, then the open cases.
*
* @return array<int, string>
*/
public static function caseOptions(InboundMessage $message): array
{
$hinted = collect((array) $message->hints)->pluck('booking_id')->all();
return Booking::query()->with('guest')
->where(fn (Builder $query) => $query->whereKey($hinted)->orWhereNotIn('status', [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed]))
->orderByRaw('CASE WHEN id IN ('.(implode(',', array_map('intval', $hinted)) ?: '0').') THEN 0 ELSE 1 END')->orderBy('arrival')
->limit(100)->get()
->mapWithKeys(fn (Booking $booking): array => [$booking->id => $booking->reference.' · '.$booking->guestName().' · '.$booking->arrival->format('d.m.').'–'.$booking->departure->format('d.m.Y')])
->all();
}
public static function getPages(): array
{
return ['index' => ListInboundMessages::route('/')];
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Filament\Resources\InboundMessages\Pages;
use App\Channels\Mail\MailboxReader;
use App\Filament\Resources\InboundMessages\InboundMessageResource;
use App\Support\Settings;
use Carbon\CarbonImmutable;
use Filament\Resources\Pages\ListRecords;
use Illuminate\Support\Facades\Cache;
class ListInboundMessages extends ListRecords
{
protected static string $resource = InboundMessageResource::class;
public function getSubheading(): ?string
{
$mailbox = Settings::tenant()?->activeMailbox();
$state = match (true) {
$mailbox === null || blank($mailbox->host) => 'Kein Postfach eingerichtet (System › Betrieb).',
! $mailbox->readsEverything() => 'Das Postfach liest nur Buchungsmails der Portale; für Gast-Mails „Alle Nachrichten“ wählen (System › Betrieb).',
default => 'Abruf jede Minute, zuletzt erfolgreich: '.(($success = Cache::get(MailboxReader::key(MailboxReader::LAST_SUCCESS_KEY))) ? CarbonImmutable::parse($success)->format('d.m.Y, H:i').' Uhr' : 'noch nie')
.(($error = Cache::get(MailboxReader::key(MailboxReader::LAST_ERROR_KEY))) ? ' · Letzter Fehler: '.mb_substr((string) $error, 0, 160) : '').'.',
};
return $state.' Zugeordnet wird nur über einen sicheren Bezug (Antwort auf unsere Mail, Vorgangsnummer und Absender, oder Absender mit Wohnung und Zeitraum). Alles andere wartet hier auf Sie; eine Nachricht legt nie selbst einen Vorgang an.';
}
}
@@ -70,7 +70,7 @@ public static function table(Table $table): Table
TextColumn::make('missing')->label('Fehlt noch')->state(fn (IntakeObservation $record): string => implode(', ', (array) $record->missing))->placeholder('–')->wrap()->toggleable(isToggledHiddenByDefault: true),
])
->filters([
SelectFilter::make('channel_id')->label('Portal')->options(fn (): array => Channel::query()->orderBy('name')->pluck('name', 'id')->all()),
SelectFilter::make('channel_id')->label('Portal')->options(fn (): array => Channel::query()->portals()->orderBy('name')->pluck('name', 'id')->all()),
SelectFilter::make('outcome')->label('Ergebnis')->options(IntakeOutcome::class),
SelectFilter::make('applied')->label('Ausgeführt')->options(['1' => 'ja', '0' => 'nur protokolliert']),
]);
@@ -217,7 +217,7 @@ public static function classificationAction(): Action
->visible(fn (Get $get): bool => in_array($get('occupation_kind'), [OccupationKind::Block, OccupationKind::Block->value], true)),
Select::make('origin_channel_id')->label('Buchungskanal, sofern persönlich bekannt')->placeholder('Unbekannt')
->helperText('Privat bezeichnet den fachlichen Ursprung. Der Importkanal bleibt als Kalenderquelle erhalten.')
->options(fn (BlockedPeriod $record): array => ['private' => 'Privat'] + Channel::query()->where('property_id', $record->property_id)->pluck('name', 'id')->all()),
->options(fn (BlockedPeriod $record): array => ['private' => 'Privat'] + Channel::query()->portals()->where('property_id', $record->property_id)->pluck('name', 'id')->all()),
])->action(function (BlockedPeriod $record, array $data, ClassifyPortalOccupation $classify): void {
$private = ($data['origin_channel_id'] ?? null) === 'private';
$classify->handle($record, $data['occupation_kind'] instanceof OccupationKind ? $data['occupation_kind'] : OccupationKind::from($data['occupation_kind']), ! $private && filled($data['origin_channel_id'] ?? null) ? (int) $data['origin_channel_id'] : null, [
@@ -213,7 +213,7 @@ private function copyToNextYearAction(): Action
->label('In Folgejahr kopieren')
->icon(Heroicon::OutlinedDocumentDuplicate)
->color('gray')
->modalDescription('Alle Saisons, die im gewählten Jahr beginnen, werden mit Preisen und Mindestnächten ins Folgejahr übernommen. Bereits belegte Zeiträume werden übersprungen.')
->modalDescription('Alle Saisons, die im gewählten Jahr beginnen, werden mit Preisen und Mindestnächten ins Folgejahr übernommen. Bestehende Saisons bleiben unverändert: Reicht eine davon in den neuen Zeitraum hinein, beginnt bzw. endet die Kopie an ihrer Grenze; liegt der Zeitraum ganz in bestehenden Saisons, wird er übersprungen.')
->schema([
Select::make('year')
->label('Jahr kopieren')
@@ -232,7 +232,11 @@ private function copyToNextYearAction(): Action
Notification::make()
->title("{$result['created']} Saisons nach ".((int) $data['year'] + 1).' kopiert')
->body($result['skipped'] > 0 ? "{$result['skipped']} übersprungen, da der Zeitraum bereits belegt ist." : 'Bitte Daten und Preise prüfen.')
->body(collect([
$result['trimmed'] > 0 ? "{$result['trimmed']} an bestehende Saisons angepasst (Beginn oder Ende verschoben)." : null,
$result['skipped'] > 0 ? "{$result['skipped']} übersprungen, da der Zeitraum bereits belegt ist." : null,
'Bitte Daten und Preise prüfen.',
])->filter()->implode(' '))
->success()
->send();
});
@@ -13,7 +13,9 @@
use App\Models\Site;
use App\Models\User;
use App\Support\Settings;
use Filament\Forms\Components\CheckboxList;
use Filament\Forms\Components\KeyValue;
use Filament\Forms\Components\Repeater;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\TimePicker;
@@ -144,6 +146,36 @@ public static function configure(Schema $schema): Schema
->placeholder('Texte der Webseite')
->helperText('Wird bei neuen Angeboten verwendet, sofern das Portal keine eigene Vorlage hat.'),
]),
Section::make('Aufenthalt vorbereiten und abschließen')
->description('Was bei jedem Aufenthalt in dieser Wohnung zu tun ist. Jede Zeile wird rechtzeitig zur Aufgabe am Vorgang – keine Personalplanung. Gebuchte Leistungen (z. B. Wäschepaket) kommen automatisch dazu.')
->collapsed()
->columnSpanFull()
->schema([
Toggle::make('asks_arrival_time')
->label('Anreisezeit erfragen')
->helperText('Fehlt sie wenige Tage vor der Anreise, erscheint die Aufgabe „Anreisedaten beim Gast erfragen“. Kontaktdaten werden immer geprüft.'),
Repeater::make('stay_tasks')
->label('Aufgaben je Aufenthalt')
->addActionLabel('Aufgabe hinzufügen')
->defaultItems(0)
->columns(4)
->schema([
TextInput::make('title')->label('Was?')->placeholder('z. B. Endreinigung')->required()->maxLength(120),
Select::make('when')->label('Wann?')->required()->default('before_arrival')->live()->options([
'before_arrival' => 'vor der Anreise',
'on_arrival' => 'am Anreisetag',
'after_departure' => 'am Abreisetag',
]),
TextInput::make('days')->label('Tage vorher')->integer()->minValue(0)->maxValue(14)->default(1)->visible(fn (Get $get): bool => $get('when') === 'before_arrival'),
TextInput::make('responsible')->label('Wer? (optional)')->placeholder('z. B. Reinigung Müller')->maxLength(120),
CheckboxList::make('applies_to')->label('Bei')->required()->default(['rental'])->columns(4)->columnSpanFull()->options([
'rental' => 'Gästebuchungen',
'private' => 'Familie/Freunde',
'own' => 'eigener Nutzung',
'block' => 'Sperren',
]),
]),
]),
Section::make('Abweichende Abwicklung dieser Wohnung')
->description('Nur nötig, wenn diese Wohnung anders bearbeitet wird als in „So arbeite ich“ eingestellt. Leere Felder folgen Ihren Standardeinstellungen.')
->visible(fn (): bool => auth()->user() instanceof User && auth()->user()->adminMode() === AdminMode::Expert)
+1 -1
View File
@@ -25,7 +25,7 @@ class ChannelController extends Controller
{
public function feed(string $token, ICalExport $feed, Request $request): Response
{
$channel = Channel::query()->where(fn ($query) => $query->where('export_token', $token)
$channel = Channel::query()->portals()->where(fn ($query) => $query->where('export_token', $token)
->orWhere(fn ($previous) => $previous->where('previous_export_token', $token)->where('previous_export_token_expires_at', '>', now())))->firstOrFail();
abort_unless($channel->servesItsLandlord(), 404);
@@ -0,0 +1,150 @@
<?php
namespace App\Http\Controllers;
use App\Actions\ContributeCaseFacts;
use App\Actions\RequestCaseData;
use App\Enums\BookingStatus;
use App\Enums\FactSource;
use App\Models\Booking;
use App\Models\CaseFact;
use App\Models\DataRequest;
use App\Process\CaseRequirements;
use App\Support\Countries;
use DateTimeInterface;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\URL;
use Illuminate\View\View;
/**
* The guest's page to complete missing details (v0.11, CH-18, signed link from the data request): no account, the link
* belongs to one case, one request and its current version. Opening it changes nothing; it shows only the details that
* are asked for and what the guest gave for this case himself. Sending goes through the common fact intake – the same
* form twice is harmless, a differing value never overwrites a stored one, and nothing binding happens here.
*/
class GuestDataController extends Controller
{
public function show(Request $request, Booking $booking): View
{
$booking->loadMissing(['guest', 'property']);
[$dataRequest, $problem] = $this->current($request, $booking);
$fields = $problem === null ? $this->fields($dataRequest, $booking) : [];
return view('guest-data', [
'booking' => $booking,
'problem' => $problem,
'fields' => $fields,
'values' => $this->ownValues($booking, $fields),
'clarification' => $booking->clarificationState(),
'purpose' => $dataRequest?->purpose,
'submitUrl' => $problem === null ? $this->signed($booking, 'guest-data.submit', now()->addHour(), $dataRequest) : null,
]);
}
public function submit(Request $request, Booking $booking, ContributeCaseFacts $facts): RedirectResponse
{
$booking->loadMissing('guest');
[$dataRequest, $problem] = $this->current($request, $booking);
$back = $dataRequest !== null ? $this->signed($booking, 'guest-data.show', now()->addDays(2), $dataRequest) : url()->previous();
if ($problem !== null) {
return redirect()->to($back)->with('guest-data.error', $problem);
}
$fields = $this->fields($dataRequest, $booking);
$rules = [];
foreach ($fields as $field) {
$rules[$this->input($field)] = match ($field) {
'guest.country' => ['nullable', 'in:'.implode(',', array_keys(Countries::options()))],
'guest.email' => ['nullable', 'email', 'max:255'],
'booking.guests' => ['nullable', 'integer', 'min:1', 'max:'.$booking->property->max_guests],
default => ['nullable', 'string', 'max:255', 'not_regex:/https?:|www\.|<|>/i'],
};
}
$input = $request->validate($rules, [], collect($fields)->mapWithKeys(fn (string $field): array => [$this->input($field) => CaseRequirements::label($field)])->all());
$given = collect($fields)->mapWithKeys(fn (string $field): array => [$field => $input[$this->input($field)] ?? null])->filter(fn (mixed $value): bool => filled($value))->all();
if ($given === []) {
return redirect()->to($back)->with('guest-data.error', 'Bitte füllen Sie mindestens eines der Felder aus.');
}
$result = $facts->handle($booking, $given, FactSource::GuestLink, [
'reference' => 'link:r'.$dataRequest->id.':v'.$dataRequest->link_version.':'.hash('sha256', json_encode($given)),
'actor' => 'Gast über den Ergänzungslink',
]);
$booking->refresh();
$stillMissing = RequestCaseData::needs($booking)['fields'] ?? [];
return redirect()->to($back)->with('guest-data.success', match (true) {
$result->isEmpty() => 'Diese Angaben liegen uns bereits vor – vielen Dank.',
$result->needsReview() => 'Vielen Dank! Einige Angaben weichen von unseren Unterlagen ab; wir prüfen sie und melden uns bei Bedarf.',
$stillMissing !== [] => 'Vielen Dank! Es fehlen noch: '.implode(', ', CaseRequirements::labels($stillMissing)).'.',
default => 'Vielen Dank – Ihre Angaben sind vollständig. Wir melden uns in Kürze per E-Mail.',
});
}
/**
* The request this link belongs to and why the link cannot be used (or null).
*
* @return array{0: ?DataRequest, 1: ?string}
*/
private function current(Request $request, Booking $booking): array
{
$dataRequest = $booking->dataRequests()->whereKey((int) $request->query('r'))->first();
if ($dataRequest === null) {
return [null, 'Dieser Link gehört nicht zu dieser Anfrage.'];
}
if ((int) $request->query('v') !== $dataRequest->link_version) {
return [$dataRequest, 'Dieser Link ist nicht mehr aktuell – wir haben Ihnen inzwischen eine neuere Nachricht gesendet. Bitte verwenden Sie den Link aus der neuesten E-Mail.'];
}
if (RequestCaseData::needs($booking) === null) {
return [$dataRequest, in_array($booking->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true)
? 'Diese Anfrage ist abgeschlossen. Gern können Sie über unsere Webseite neu anfragen.'
: 'Vielen Dank – uns liegen alle Angaben vor. Sie müssen nichts weiter tun.'];
}
return [$dataRequest, null];
}
/**
* The details asked for now, plus the phone number as an optional extra.
*
* @return list<string>
*/
private function fields(?DataRequest $dataRequest, Booking $booking): array
{
$needed = RequestCaseData::needs($booking)['fields'] ?? (array) $dataRequest?->fields;
return array_values(array_unique([...$needed, ...(blank($booking->guest?->phone) ? ['guest.phone'] : [])]));
}
/**
* Pre-filled values: only what this guest gave for this case himself (minimal insight, CH-18), and Germany as a
* changeable default of the country (B4).
*
* @param list<string> $fields
* @return array<string, string>
*/
private function ownValues(Booking $booking, array $fields): array
{
$own = CaseFact::query()->where('booking_id', $booking->id)->whereIn('field', $fields)
->whereIn('source', [FactSource::GuestLink, FactSource::WebsiteForm])->whereIn('outcome', [CaseFact::APPLIED, CaseFact::CONFIRMED])
->orderBy('id')->get()->mapWithKeys(fn (CaseFact $fact): array => [$fact->field => (string) $fact->value])->all();
return in_array('guest.country', $fields, true) && ! isset($own['guest.country']) ? [...$own, 'guest.country' => Countries::DEFAULT] : $own;
}
private function input(string $field): string
{
return str_replace('.', '_', $field);
}
private function signed(Booking $booking, string $name, DateTimeInterface $expiration, DataRequest $dataRequest): string
{
$parameters = ['booking' => $booking, 'r' => $dataRequest->id, 'v' => $dataRequest->link_version];
return $booking->website()?->temporarySignedRoute($name, $expiration, $parameters)
?? URL::temporarySignedRoute($name, $expiration, $parameters);
}
}
@@ -0,0 +1,71 @@
<?php
namespace App\Http\Controllers;
use App\Actions\SubmitBookingWish;
use App\Exceptions\ReservationException;
use App\Models\Booking;
use DateTimeInterface;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\URL;
/**
* The guest's page of an information "unter Vorbehalt" (package 7, signed link from the mail): shows price and conditions
* as checked when it was sent, says plainly that nothing is reserved or binding, and lets the guest ask for the booking.
*/
class InformationController extends Controller
{
public function show(Request $request, Booking $booking, SubmitBookingWish $wish): View
{
$booking->loadMissing(['guest', 'property']);
$version = (int) $request->query('v');
$problem = null;
try {
$wish->ensureCurrent($booking, $version);
} catch (ReservationException $exception) {
$problem = $exception->getMessage();
}
return view('information', [
'booking' => $booking,
'problem' => $problem,
'canAsk' => $problem === null,
'wishUrl' => $this->signed($booking, 'information.wish', $booking->information_valid_until?->isFuture() ? $booking->information_valid_until : now()->addHour(), $version),
]);
}
public function wish(Request $request, Booking $booking, SubmitBookingWish $wish): RedirectResponse
{
$request->validate(['terms' => ['accepted']], ['terms.accepted' => 'Bitte bestätigen Sie, dass Sie die Angaben und Bedingungen gelesen haben.']);
$version = (int) $request->query('v');
$back = $this->signed($booking, 'information.show', now()->addDays(30), $version);
try {
$outcome = $wish->handle($booking, $version, $request->ip());
} catch (ReservationException $exception) {
return redirect()->to($back)->with('information.error', $exception->getMessage());
}
$booking->refresh();
return redirect()->to($back)->with('information.success', match ($outcome) {
SubmitBookingWish::CONFIRMED => $booking->confirmation_sent_at !== null
? 'Vielen Dank! Wir haben Verfügbarkeit und Preis geprüft – Ihre Buchung ist verbindlich bestätigt. Die Bestätigung mit dem Mietvertrag haben wir Ihnen per E-Mail gesendet.'
: 'Vielen Dank! Ihre Buchung ist verbindlich bestätigt. Die Bestätigung mit dem Mietvertrag erhalten Sie in Kürze per E-Mail.',
SubmitBookingWish::PENDING => 'Vielen Dank – Ihr Buchungswunsch ist eingegangen. Wir prüfen ihn und melden uns in Kürze. Die Buchung ist noch nicht verbindlich; sie wird es erst mit unserer Buchungsbestätigung.',
SubmitBookingWish::UNAVAILABLE => 'Leider ist der Zeitraum inzwischen vergeben. Es ist keine Buchung zustande gekommen. Vielleicht passt ein anderer Termin?',
default => 'Ihr Buchungswunsch liegt uns bereits vor – Sie müssen nichts weiter tun.',
});
}
private function signed(Booking $booking, string $name, DateTimeInterface $expiration, int $version): string
{
$parameters = ['booking' => $booking, 'v' => $version];
return $booking->website()?->temporarySignedRoute($name, $expiration, $parameters)
?? URL::temporarySignedRoute($name, $expiration, $parameters);
}
}
+31
View File
@@ -0,0 +1,31 @@
<?php
namespace App\Listeners;
use App\Actions\RequestCaseData;
use App\Events\CaseFactsContributed;
use App\Models\CaseFact;
use Throwable;
/**
* After details arrived for a case, the running data request learns about it: reminders stop, a follow-up question is
* planned or the request ends (CH-17). A problem here never undoes the details that were taken over.
*/
class ContinueDataRequest
{
public function __construct(private RequestCaseData $requests) {}
public function handle(CaseFactsContributed $event): void
{
try {
$this->requests->answered($event->booking, $event->contribution, $event->source);
// Now the guest can be written to: ask for what is still missing (e.g. a portal booking's address).
if (in_array('guest.email', $event->contribution->fields(CaseFact::APPLIED), true) && $event->booking->openDataRequest() === null) {
$this->requests->forNextStep($event->booking->refresh());
}
} catch (Throwable $exception) {
report($exception);
}
}
}
+17 -1
View File
@@ -15,6 +15,18 @@
*/
class LogBookingMail
{
/**
* The Message-ID header as sent (not the transport's id), with angle brackets as replies quote it.
*/
public static function messageId(MessageSent $event): ?string
{
// The raw message as it went out carries the header; the transport's own id may differ (SMTP queue ids).
$raw = $event->sent->getSymfonySentMessage()->getMessage()->toString();
$headers = substr($raw, 0, (int) (strpos($raw, "\r\n\r\n") ?: strlen($raw)));
return preg_match('/^Message-ID:\s*(<[^>\r\n]+>)/mi', $headers, $match) ? $match[1] : null;
}
public function handle(MessageSent $event): void
{
try {
@@ -25,12 +37,16 @@ public function handle(MessageSent $event): void
$recipients = collect($event->message->getTo())->map(fn ($address): string => mb_strtolower($address->getAddress()));
$guest = mb_strtolower((string) $booking->guest?->email);
$audience = ! Settings::isLive() ? 'test' : ($guest !== '' && $recipients->contains($guest) ? 'guest' : 'landlord');
// A redirected mail carries the original recipients (EnforceMailTestMode); it never reached them.
$redirected = $event->message->getHeaders()->has(EnforceMailTestMode::ORIGINAL_RECIPIENTS_HEADER);
$audience = $redirected || ! Settings::isLive() ? 'test' : ($guest !== '' && $recipients->contains($guest) ? 'guest' : 'landlord');
BookingMessage::query()->create([
'booking_id' => $booking->id,
'audience' => $audience,
'subject' => mb_substr((string) $event->message->getSubject(), 0, 255),
// v0.11: the Message-ID lets a reply be assigned to its case (CH-13, "bekannter Antwortbezug").
'message_id' => rescue(fn (): ?string => self::messageId($event), null, false),
'sent_at' => now(),
]);
} catch (Throwable) {
+33 -3
View File
@@ -15,6 +15,8 @@
use App\Pricing\PriceQuote;
use App\Pricing\QuoteException;
use App\Pricing\StayRequest;
use App\Process\ProcessSettings;
use App\Support\Countries;
use App\Tenancy\TenantContext;
use Carbon\CarbonImmutable;
use Illuminate\Contracts\View\View;
@@ -63,6 +65,9 @@ class BookingRequest extends Component
public string $city = '';
/** Pre-filled but changeable; it only counts because the guest sends it with the form (B4). */
public string $country = Countries::DEFAULT;
public string $message = '';
public bool $privacyAccepted = false;
@@ -104,6 +109,25 @@ public function property(): Property
return Property::findOrFail($this->propertyId);
}
/**
* Whether the full address must be given in the form (channel manager, website entry; default: no – missing
* details are asked for afterwards, v0.11 B2).
*/
#[Computed]
public function requiresAddress(): bool
{
return app(ProcessSettings::class)->forWebsite($this->property)->formRequiresAddress();
}
/**
* Whether a request on the website reserves the dates (else it is answered with an information, package 7).
*/
#[Computed]
public function reservesDates(): bool
{
return app(ProcessSettings::class)->forWebsite($this->property)->preReservation();
}
/**
* @return Collection<int, Extra>
*/
@@ -251,6 +275,7 @@ public function submit(CreateReservation $createReservation): void
'street' => $this->street ?: null,
'postal_code' => $this->postalCode ?: null,
'city' => $this->city ?: null,
'country' => $this->country ?: null,
],
$this->message ?: null,
attribution: [...$this->utm, 'referral_source' => $this->referralSource ?: null],
@@ -318,9 +343,10 @@ protected function rules(): array
'lastName' => ['required', 'string', 'max:255', 'not_regex:/https?:|www\.|<|>/i'],
'email' => ['required', 'email', 'max:255'],
'phone' => ['nullable', 'string', 'max:50'],
'street' => ['nullable', 'string', 'max:255'],
'postalCode' => ['nullable', 'string', 'max:20'],
'city' => ['nullable', 'string', 'max:255'],
'street' => [$this->requiresAddress() ? 'required' : 'nullable', 'string', 'max:255'],
'postalCode' => [$this->requiresAddress() ? 'required' : 'nullable', 'string', 'max:20'],
'city' => [$this->requiresAddress() ? 'required' : 'nullable', 'string', 'max:255'],
'country' => [$this->requiresAddress() ? 'required' : 'nullable', Rule::in(array_keys(Countries::options()))],
'message' => ['nullable', 'string', 'max:5000', function (string $attribute, mixed $value, \Closure $fail): void {
if (preg_match_all('~https?://|www\.~i', (string) $value) > config('fewo.spam.max_links')) {
$fail('Bitte schreiben Sie Ihre Nachricht ohne Links.');
@@ -343,6 +369,10 @@ protected function validationAttributes(): array
'firstName' => 'Vorname',
'lastName' => 'Nachname',
'email' => 'E-Mail',
'street' => 'Straße & Hausnr.',
'postalCode' => 'PLZ',
'city' => 'Ort',
'country' => 'Land',
'privacyAccepted' => 'Datenschutzerklärung',
];
}
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Mail;
use App\Models\Booking;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* Answer to the guest's booking wish while nothing is binding (package 7): received and being checked (`pending`),
* dates given away meanwhile (`unavailable`) or not confirmed by the landlord (`declined`). The confirmation itself is
* the usual booking confirmation with the contract.
*/
class BookingWishAnswered extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking, public string $outcome) {}
public function envelope(): Envelope
{
return new Envelope(
subject: ($this->outcome === 'pending' ? 'Ihr Buchungswunsch ist eingegangen' : 'Ihr Buchungswunsch').' – '.$this->booking->reference,
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
public function content(): Content
{
return new Content(markdown: 'mail.booking-wish-answered');
}
}
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Mail;
use App\Filament\Resources\Bookings\BookingResource;
use App\Models\Booking;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* Tells the landlord about a booking wish (package 7): confirmed automatically, waiting for the confirmation, or
* arrived after the dates were given away.
*/
class BookingWishNotice extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking, public string $outcome) {}
public function envelope(): Envelope
{
return new Envelope(subject: match ($this->outcome) {
'confirmed' => 'Buchungswunsch automatisch bestätigt',
'unavailable' => 'Buchungswunsch – Zeitraum inzwischen vergeben',
default => 'Buchungswunsch bitte bestätigen',
}.' '.$this->booking->reference.': '.$this->booking->guestName().', '.$this->booking->arrival->format('d.m.').'–'.$this->booking->departure->format('d.m.Y'));
}
public function content(): Content
{
return new Content(markdown: 'mail.booking-wish-notice', with: ['caseUrl' => BookingResource::getUrl('view', ['record' => $this->booking])]);
}
}
+66
View File
@@ -0,0 +1,66 @@
<?php
namespace App\Mail;
use App\Actions\RequestCaseData;
use App\Models\Booking;
use App\Models\DataRequest;
use App\Process\CaseRequirements;
use App\Support\Settings;
use Carbon\CarbonImmutable;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* The question for missing details (v0.11, S4): first question, targeted follow-up or reminder, with the guest's link.
* What it says about the dates follows the real state of the case at the moment of sending (CH §2a table): no hold,
* a clarification hold until its real end, an expired one, or a booking that is already binding – never the
* configured value. The guest may also simply answer the e-mail.
*/
class DataRequested extends Mailable
{
use Queueable, SerializesModels;
/** @var array{state: 'none'|'active'|'expired', until: ?CarbonImmutable} */
public array $clarification;
/** @var list<string> */
public array $missing;
public function __construct(public Booking $booking, public DataRequest $request, public string $kind, public string $url)
{
$this->clarification = $booking->clarificationState();
$this->missing = CaseRequirements::labels($request->fields);
}
public function envelope(): Envelope
{
$subject = $this->request->purpose === RequestCaseData::FOR_BOOKING ? 'Ihre Buchung '.$this->booking->reference : 'Ihre Anfrage '.$this->booking->reference;
return new Envelope(
subject: match ($this->kind) {
DataRequest::REMINDER => 'Erinnerung – '.$subject.': Es fehlen noch Angaben',
DataRequest::FOLLOWUP => $subject.': Noch eine kurze Rückfrage',
default => $subject.': Bitte ergänzen Sie Ihre Angaben',
},
// Answers go to the dedicated mailbox when one is read completely (v0.11 inbox), so they reach the case.
replyTo: [new Address(self::replyAddress(), config('fewo.owner.name'))],
);
}
public static function replyAddress(): string
{
$mailbox = Settings::tenant()?->activeMailbox();
return $mailbox?->readsEverything() && filled($mailbox->address) ? (string) $mailbox->address : (string) config('fewo.owner.email');
}
public function content(): Content
{
return new Content(markdown: 'mail.data-requested');
}
}
+35
View File
@@ -0,0 +1,35 @@
<?php
namespace App\Mail;
use App\Models\Booking;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* The information "unter Vorbehalt" (package 7): price and availability as checked now, no reservation, no acceptance
* link – only the link to ask for the booking, which is checked again before anything becomes binding.
*/
class InformationSent extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking, public string $url) {}
public function envelope(): Envelope
{
return new Envelope(
subject: 'Unverbindliche Auskunft zu Ihrer Anfrage '.$this->booking->reference,
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
public function content(): Content
{
return new Content(markdown: 'mail.information-sent');
}
}
+5 -1
View File
@@ -22,7 +22,11 @@ public function __construct(public Booking $booking) {}
public function envelope(): Envelope
{
return new Envelope(
subject: 'Ihre Anfrage '.$this->booking->reference.($this->booking->isHoldActive() ? ' – Termin vorgemerkt, Angebot folgt' : ' – Eingang bestätigt, Angebot folgt'),
subject: 'Ihre Anfrage '.$this->booking->reference.match (true) {
$this->booking->isHoldActive() && $this->booking->hold_purpose === Booking::HOLD_CLARIFICATION => ' – Eingang bestätigt, vorläufig reserviert',
$this->booking->isHoldActive() => ' – Termin vorgemerkt, Angebot folgt',
default => ' – Eingang bestätigt, Angebot folgt',
},
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
+64
View File
@@ -18,6 +18,7 @@
use App\Process\CaseRecorder;
use App\Process\ProcessProfile;
use App\Process\ProcessSettings;
use Carbon\CarbonImmutable;
use Carbon\CarbonInterface;
use Database\Factories\BookingFactory;
use Illuminate\Database\Eloquent\Attributes\Fillable;
@@ -71,6 +72,7 @@
'balance_due_on',
'contract_path',
'hold_expires_at',
'hold_purpose',
'offer_version',
'offer_sent_at',
'offer_message',
@@ -99,6 +101,17 @@
'tourist_tax_note',
'portal_cancellation_requested_at',
'export_uid',
'information_version',
'information_sent_at',
'information_valid_until',
'information',
'wish_at',
'wish',
'arrival_time',
'completed_at',
'settled_at',
'settled_note',
'settled_by',
])]
class Booking extends Model
{
@@ -107,6 +120,12 @@ class Booking extends Model
public const DIRECT_SOURCES = ['website', 'manual', 'phone', 'direct', 'email', 'internal'];
/** The hold of a request or an offer (unchanged behaviour of v0.10). */
public const HOLD_OFFER = 'offer';
/** The short hold of an incomplete request while details are fetched (v0.11, E-033). */
public const HOLD_CLARIFICATION = 'clarification';
public function isDirect(): bool
{
return $this->import_channel_id === null && $this->origin_channel_id === null && in_array($this->source, self::DIRECT_SOURCES, true);
@@ -187,6 +206,13 @@ protected function casts(): array
'archived_at' => 'immutable_datetime',
'internal_kind' => InternalKind::class,
'portal_cancellation_requested_at' => 'immutable_datetime',
'information_sent_at' => 'immutable_datetime',
'information_valid_until' => 'immutable_datetime',
'information' => 'array',
'wish_at' => 'immutable_datetime',
'wish' => 'array',
'completed_at' => 'immutable_datetime',
'settled_at' => 'immutable_datetime',
];
}
@@ -493,11 +519,49 @@ public function canBeArchived(): bool
|| ($this->departure->isPast() && in_array($this->status, BookingStatus::occupying(), true));
}
/** @return HasMany<InboundMessage, $this> */
public function inboundMessages(): HasMany
{
return $this->hasMany(InboundMessage::class);
}
/** @return HasMany<DataRequest, $this> */
public function dataRequests(): HasMany
{
return $this->hasMany(DataRequest::class)->latest('id');
}
/**
* The request for missing details that still runs (at most one per case, CH-17).
*/
public function openDataRequest(): ?DataRequest
{
return $this->dataRequests()->whereIn('status', DataRequest::RUNNING)->first();
}
public function isHoldActive(): bool
{
return in_array($this->status, BookingStatus::holding(), true) && $this->hold_expires_at?->isFuture();
}
/**
* The real state of the clarification hold, for what the guest may be told (v0.11, CH §2a table): none (setting 0,
* not qualified, or no clarification at all), active until a real point in time, or expired. Only this – never the
* configured value – may be put into a message.
*
* @return array{state: 'none'|'active'|'expired', until: ?CarbonImmutable}
*/
public function clarificationState(): array
{
if ($this->hold_purpose !== self::HOLD_CLARIFICATION || $this->hold_expires_at === null) {
return ['state' => 'none', 'until' => null];
}
return $this->isHoldActive()
? ['state' => 'active', 'until' => $this->hold_expires_at]
: ['state' => 'expired', 'until' => $this->hold_expires_at];
}
/**
* The website this stay belongs to, regardless of which landlord is current.
*/
+2 -2
View File
@@ -11,7 +11,7 @@
/**
* An e-mail that went out for a booking (communication log). Only subject and audience are kept.
*/
#[Fillable(['booking_id', 'audience', 'subject', 'sent_at'])]
#[Fillable(['booking_id', 'audience', 'subject', 'message_id', 'sent_at'])]
class BookingMessage extends Model
{
public $timestamps = false;
@@ -25,7 +25,7 @@ protected static function booted(): void
CaseLog::record($message->booking, 'mail', 'E-Mail '.match ($message->audience) {
'guest' => 'an den Gast',
'landlord' => 'an uns',
default => '(Testbetrieb)',
default => 'im Testbetrieb an die Testadresse (nicht an den Gast)',
}.': '.$message->subject, actor: CaseLog::SYSTEM, at: $message->sent_at);
}
});
+36 -5
View File
@@ -5,6 +5,7 @@
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Models\Concerns\BelongsToTenant;
use App\Process\CaseClosure;
use App\Process\CaseLog;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Attributes\Scope;
@@ -16,7 +17,7 @@
* Something the landlord has to do about a booking. One task per booking and kind; a finished or
* dismissed task is never created again.
*/
#[Fillable(['booking_id', 'kind', 'status', 'due_on', 'note', 'completed_by', 'completed_at'])]
#[Fillable(['booking_id', 'kind', 'subject', 'title', 'responsible', 'status', 'due_on', 'note', 'completed_by', 'completed_at'])]
class BookingTask extends Model
{
use BelongsToTenant;
@@ -25,12 +26,19 @@ protected static function booted(): void
{
static::created(function (BookingTask $task): void {
if ($task->booking !== null) {
CaseLog::record($task->booking, 'task', 'Aufgabe: '.$task->kind->getLabel());
CaseLog::record($task->booking, 'task', 'Aufgabe: '.$task->label().($task->responsible ? ' (zuständig: '.$task->responsible.')' : ''));
if ($task->kind->isCommercial() && $task->status === BookingTaskStatus::Open) {
CaseClosure::refresh($task->booking);
}
}
});
static::updated(function (BookingTask $task): void {
if ($task->wasChanged('status') && $task->status !== BookingTaskStatus::Open && $task->booking !== null) {
CaseLog::record($task->booking, 'task', 'Aufgabe '.($task->status === BookingTaskStatus::Done ? 'erledigt' : 'verworfen').': '.$task->kind->getLabel(), actor: $task->completed_by);
CaseLog::record($task->booking, 'task', 'Aufgabe '.($task->status === BookingTaskStatus::Done ? 'erledigt' : 'verworfen').': '.$task->label().($task->wasChanged('note') && filled($task->note) ? ' – '.$task->note : ''), actor: $task->completed_by);
}
// Money tasks decide the commercial closing of the case (package 9).
if ($task->wasChanged('status') && $task->booking !== null && $task->kind->isCommercial()) {
CaseClosure::refresh($task->booking);
}
});
}
@@ -68,8 +76,31 @@ protected function open(Builder $query): Builder
return $query->where('status', BookingTaskStatus::Open);
}
public function complete(string $by): void
public function complete(string $by, ?string $note = null): void
{
$this->update(['status' => BookingTaskStatus::Done, 'completed_by' => $by, 'completed_at' => now()]);
$this->update(['status' => BookingTaskStatus::Done, 'completed_by' => $by, 'completed_at' => now(), ...($note !== null && $note !== '' ? ['note' => mb_substr($note, 0, 1000)] : [])]);
}
/**
* What the task is about in plain words: its own title (services, issues, follow-ups) or the label of its kind.
*/
public function label(): string
{
return filled($this->title) ? (string) $this->title : $this->kind->getLabel();
}
/**
* Opens the task of this kind and subject for the case once; a task that was done or dismissed is not opened again.
*
* @param array<string, mixed> $attributes
*/
public static function openOnce(Booking $booking, BookingTaskKind $kind, string $subject = '', array $attributes = []): self
{
$task = static::withoutGlobalScope('tenant')->firstOrNew(['booking_id' => $booking->id, 'kind' => $kind, 'subject' => $subject]);
if (! $task->exists) {
$task->forceFill(['tenant_id' => $booking->tenant_id, 'status' => BookingTaskStatus::Open, ...$attributes])->save();
}
return $task;
}
}
+65
View File
@@ -0,0 +1,65 @@
<?php
namespace App\Models;
use App\Enums\FactSource;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* One detail that arrived for a case, with its source and what became of it (v0.11, S5). Only appended, never
* changed: the evidence behind the values in guests and bookings.
*/
#[Fillable(['booking_id', 'field', 'value', 'previous_value', 'source', 'inbound_message_id', 'evidence', 'confidence', 'outcome', 'fingerprint', 'actor', 'created_at'])]
class CaseFact extends Model
{
use BelongsToTenant;
public const UPDATED_AT = null;
public const APPLIED = 'applied';
public const CONFIRMED = 'confirmed';
public const CONFLICT = 'conflict';
public const CHANGE_REQUEST = 'change_request';
public const REJECTED = 'rejected';
/**
* @return array<string, string>
*/
protected function casts(): array
{
return [
'value' => 'encrypted',
'previous_value' => 'encrypted',
'evidence' => 'encrypted',
'source' => FactSource::class,
'confidence' => 'float',
'created_at' => 'immutable_datetime',
];
}
/**
* @return BelongsTo<Booking, $this>
*/
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
public function outcomeLabel(): string
{
return match ($this->outcome) {
self::APPLIED => 'übernommen',
self::CONFIRMED => 'bestätigt (gleicher Wert)',
self::CONFLICT => 'weicht ab – zur Prüfung',
self::CHANGE_REQUEST => 'Änderungswunsch – zur Prüfung',
default => 'nicht verwendbar',
};
}
}
+52 -5
View File
@@ -24,20 +24,26 @@
use Illuminate\Support\Str;
/**
* A sales channel (portal) of a property. Our system leads: occupations are imported from the
* channel and every channel gets its own export feed without its own occupations.
* A sales channel of a property. A portal (kind "portal"): our system leads, occupations are imported from the
* channel and every channel gets its own export feed without its own occupations. The own website (kind "website",
* v0.11 channel manager) only carries the settings for requests from the website: it is never synchronised,
* exported, monitored or given blocking tasks, and cases from the website stay direct (A1) without a channel.
*/
#[Fillable(['property_id', 'name', 'connector', 'settings', 'is_active', 'requires_manual_blocking', 'manage_url', 'status', 'booking_model', 'import_enabled', 'export_enabled', 'export_mode', 'external_poll_minutes', 'echo_behavior', 'echo_notes', 'operating_notes', 'portal_verified_at', 'payment_tasks_inquiry', 'payment_tasks_reservation', 'contract_template_id', 'contract_template_reservation_id', 'process_overrides', 'case_intake'])]
#[Fillable(['property_id', 'name', 'connector', 'settings', 'is_active', 'requires_manual_blocking', 'manage_url', 'status', 'booking_model', 'import_enabled', 'export_enabled', 'export_mode', 'external_poll_minutes', 'echo_behavior', 'echo_notes', 'operating_notes', 'portal_verified_at', 'payment_tasks_inquiry', 'payment_tasks_reservation', 'contract_template_id', 'contract_template_reservation_id', 'process_overrides', 'case_intake', 'kind'])]
#[Hidden(['export_token', 'previous_export_token', 'export_snapshot', 'settings', 'ical_analysis'])]
class Channel extends Model
{
/** @use HasFactory<ChannelFactory> */
use BelongsToTenant, HasFactory;
public const KIND_PORTAL = 'portal';
public const KIND_WEBSITE = 'website';
protected $attributes = [
'status' => 'setup', 'booking_model' => 'mixed', 'import_enabled' => false,
'export_enabled' => false, 'export_mode' => 'test',
'echo_behavior' => 'unverified', 'case_intake' => 'off',
'echo_behavior' => 'unverified', 'case_intake' => 'off', 'kind' => self::KIND_PORTAL,
];
protected static function booted(): void
@@ -138,7 +144,48 @@ public function tasks(): HasMany
#[Scope]
protected function active(Builder $query): Builder
{
return $query->where('is_active', true)->where('status', ChannelStatus::Active);
return $query->where('is_active', true)->where('status', ChannelStatus::Active)->where('kind', self::KIND_PORTAL);
}
/**
* Portals only (active or not) – everything except the own website's settings entry.
*
* @param Builder<Channel> $query
* @return Builder<Channel>
*/
#[Scope]
protected function portals(Builder $query): Builder
{
return $query->where('kind', self::KIND_PORTAL);
}
public function isWebsite(): bool
{
return $this->kind === self::KIND_WEBSITE;
}
public function isPortal(): bool
{
return ! $this->isWebsite();
}
/**
* The settings entry of the property's own website, created on first use.
*/
public static function websiteOf(Property $property): self
{
return self::withoutGlobalScopes()->firstOrCreate(
['property_id' => $property->id, 'kind' => self::KIND_WEBSITE],
['tenant_id' => $property->tenant_id, 'name' => 'Eigene Webseite', 'connector' => self::KIND_WEBSITE, 'status' => ChannelStatus::Active, 'booking_model' => ChannelBookingModel::Inquiry],
);
}
/**
* The settings entry of the property's own website if there is one (no write, for resolving settings).
*/
public static function existingWebsiteOf(Property $property): ?self
{
return self::withoutGlobalScopes()->where('property_id', $property->id)->where('kind', self::KIND_WEBSITE)->first();
}
public function connector(): ChannelConnector
+87
View File
@@ -0,0 +1,87 @@
<?php
namespace App\Models;
use App\Enums\DataRequestMode;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* One coherent request for missing details of a case (v0.11, CH-16/17): at most one is open per case. Follow-up
* questions and reminders have separate counters that a partial answer never resets; the answer deadline is not a
* reservation deadline.
*/
#[Fillable(['booking_id', 'status', 'mode', 'purpose', 'fields', 'followups_sent', 'reminders_sent', 'link_version', 'last_message', 'last_sent_at', 'response_due_at', 'next_reminder_at', 'answered_at', 'closed_at', 'closed_reason'])]
class DataRequest extends Model
{
use BelongsToTenant;
/** Prepared, waits for the landlord's release. */
public const DRAFT = 'draft';
/** Sent; the guest is asked and may be reminded. */
public const OPEN = 'open';
/** The landlord asks himself (no automatic message), or the limits were reached. */
public const MANUAL = 'manual';
/** Every requested detail is there. */
public const COMPLETED = 'completed';
/** Ended without the details (case closed, landlord stopped it). */
public const STOPPED = 'stopped';
/** Statuses of a request that still runs. */
public const RUNNING = [self::DRAFT, self::OPEN, self::MANUAL];
/** First question. */
public const INITIAL = 'initial';
/** Targeted follow-up question after a partial or unclear answer. */
public const FOLLOWUP = 'followup';
/** Reminder when no answer came. */
public const REMINDER = 'reminder';
/**
* @return array<string, string>
*/
protected function casts(): array
{
return [
'mode' => DataRequestMode::class,
'fields' => 'array',
'last_sent_at' => 'immutable_datetime',
'response_due_at' => 'immutable_datetime',
'next_reminder_at' => 'immutable_datetime',
'answered_at' => 'immutable_datetime',
'closed_at' => 'immutable_datetime',
];
}
/**
* @return BelongsTo<Booking, $this>
*/
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
public function isRunning(): bool
{
return in_array($this->status, self::RUNNING, true);
}
public function statusLabel(): string
{
return match ($this->status) {
self::DRAFT => 'Rückfrage vorbereitet – wartet auf Ihre Freigabe',
self::OPEN => 'beim Gast angefragt',
self::MANUAL => 'von Ihnen nachzufragen',
self::COMPLETED => 'alle Angaben da',
default => 'beendet',
};
}
}
+72
View File
@@ -0,0 +1,72 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* A message read from the landlord's mailbox (v0.11, S2/S3), stored before anything is done with it. It is assigned
* to a case only by a reliable reference (CH-13); otherwise it waits in the inbox for the landlord. Being assigned is
* not yet permission to take anything over.
*/
#[Fillable(['mailbox_id', 'message_id', 'in_reply_to', 'references', 'from_address', 'from_name', 'to_addresses', 'subject', 'body', 'received_at', 'test_mode', 'status', 'booking_id', 'match_reason', 'hints', 'portal_email_id', 'extraction_status', 'extraction', 'processed_at'])]
class InboundMessage extends Model
{
use BelongsToTenant;
public const NEW = 'new';
/** Assigned to a case by a reliable reference. */
public const ASSIGNED = 'assigned';
/** Waits for the landlord: no or no reliable reference, or contradicting hints. */
public const NEEDS_REVIEW = 'needs_review';
/** A portal notification, handled by the existing portal path. */
public const PORTAL = 'portal';
public const IGNORED = 'ignored';
/** Done: details taken over or decided by the landlord. */
public const PROCESSED = 'processed';
/**
* @return array<string, string>
*/
protected function casts(): array
{
return [
'body' => 'encrypted',
'references' => 'array',
'to_addresses' => 'array',
'hints' => 'array',
'extraction' => 'array',
'test_mode' => 'boolean',
'received_at' => 'immutable_datetime',
'processed_at' => 'immutable_datetime',
];
}
/**
* @return BelongsTo<Booking, $this>
*/
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
public function statusLabel(): string
{
return match ($this->status) {
self::ASSIGNED => 'einem Vorgang zugeordnet',
self::NEEDS_REVIEW => 'zu klären',
self::PORTAL => 'Portal-Mail',
self::IGNORED => 'ignoriert',
self::PROCESSED => 'erledigt',
default => 'neu',
};
}
}
+62
View File
@@ -0,0 +1,62 @@
<?php
namespace App\Models;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Attributes\Hidden;
use Illuminate\Database\Eloquent\Model;
/**
* A landlord's IMAP mailbox (v0.11, CH-05). Several may exist, one is active. "portal_only" reads the portals'
* booking notifications as before; "full" reads every message of a mailbox dedicated to guest communication.
*/
#[Fillable(['label', 'host', 'port', 'encryption', 'username', 'password', 'folder', 'address', 'mode', 'is_active', 'last_fetched_at'])]
#[Hidden(['password'])]
class Mailbox extends Model
{
use BelongsToTenant;
public const PORTAL_ONLY = 'portal_only';
public const FULL = 'full';
/**
* @return array<string, string>
*/
protected function casts(): array
{
return [
'password' => 'encrypted',
'is_active' => 'boolean',
'port' => 'integer',
'last_fetched_at' => 'immutable_datetime',
];
}
public function readsEverything(): bool
{
return $this->mode === self::FULL;
}
/**
* Connection data in the form the reader expects, or null when it is not usable.
*
* @return array{host: string, port: int, encryption: string, username: string, password: ?string, folder: string}|null
*/
public function connection(): ?array
{
if (blank($this->host) || blank($this->username)) {
return null;
}
return [
'host' => (string) $this->host,
'port' => (int) ($this->port ?: 993),
'encryption' => (string) ($this->encryption ?: 'ssl'),
'username' => (string) $this->username,
'password' => $this->password,
'folder' => (string) ($this->folder ?: 'INBOX'),
];
}
}
+2 -2
View File
@@ -2,11 +2,11 @@
namespace App\Models;
use App\Actions\RecordPayment;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Models\Concerns\BelongsToTenant;
use App\Process\CaseLog;
use App\Support\Money;
use Database\Factories\PaymentFactory;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -27,7 +27,7 @@ protected static function booted(): void
{
static::created(function (Payment $payment): void {
if ($payment->booking !== null) {
CaseLog::record($payment->booking, 'payment', ($payment->kind ?? PaymentKind::Guest)->getLabel().': '.Money::format(abs($payment->amount)).($payment->source ? ' ('.$payment->source.')' : ''), data: ['payment_id' => $payment->id]);
CaseLog::record($payment->booking, 'payment', RecordPayment::summary($payment->booking, $payment->kind ?? PaymentKind::Guest, (int) $payment->amount, $payment->paid_on, $payment->source), data: ['payment_id' => $payment->id, 'kind' => ($payment->kind ?? PaymentKind::Guest)->value]);
}
});
}
+36 -1
View File
@@ -13,6 +13,7 @@
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Support\Str;
/**
* A rentable holiday apartment. All money amounts are stored in euro cents.
@@ -47,6 +48,8 @@
'min_stay_absolute',
'is_active',
'process_overrides',
'stay_tasks',
'asks_arrival_time',
])]
class Property extends Model
{
@@ -85,6 +88,8 @@ protected function casts(): array
'free_cancellation_days' => 'integer',
'contract_data' => 'array',
'process_overrides' => 'array',
'stay_tasks' => 'array',
'asks_arrival_time' => 'boolean',
'min_stay_fill_gaps' => 'boolean',
'min_stay_until_changeover' => 'boolean',
'changeover_weekday' => 'integer',
@@ -127,9 +132,12 @@ public function blockedPeriods(): HasMany
/**
* @return HasMany<Channel, $this>
*/
/**
* The portals of the property (the own website's settings entry is not a portal).
*/
public function channels(): HasMany
{
return $this->hasMany(Channel::class);
return $this->hasMany(Channel::class)->where('kind', Channel::KIND_PORTAL);
}
/**
@@ -188,4 +196,31 @@ public function extras(): HasMany
{
return $this->hasMany(Extra::class)->orderBy('sort_order');
}
/**
* The stay tasks of this property (package 9): local services and provider jobs such as cleaning, linen or the key
* handover, each with when it is due and for which kinds of stays it applies. No staff planning – a task per case.
*
* @return list<array{key: string, title: string, when: string, days: int, responsible: ?string, applies_to: list<string>}>
*/
public function stayTaskDefinitions(): array
{
$definitions = [];
foreach ((array) ($this->stay_tasks ?? []) as $task) {
$title = trim((string) ($task['title'] ?? ''));
if ($title === '') {
continue;
}
$definitions[] = [
'key' => 'stay:'.mb_substr(Str::slug($title), 0, 70),
'title' => $title,
'when' => in_array($task['when'] ?? null, ['before_arrival', 'on_arrival', 'after_departure'], true) ? $task['when'] : 'before_arrival',
'days' => max(0, (int) ($task['days'] ?? 1)),
'responsible' => filled($task['responsible'] ?? null) ? trim((string) $task['responsible']) : null,
'applies_to' => array_values(array_filter((array) ($task['applies_to'] ?? ['rental']))) ?: ['rental'],
];
}
return $definitions;
}
}
+14
View File
@@ -123,6 +123,12 @@ public function serviceUsages(): HasMany
*/
public function mailbox(): ?array
{
// v0.11: the active mailbox record leads; the tenant columns remain the fallback until every system migrated.
$mailbox = $this->activeMailbox();
if ($mailbox !== null) {
return $mailbox->connection();
}
if (blank($this->mailbox_host) || blank($this->mailbox_username)) {
return null;
}
@@ -137,6 +143,14 @@ public function mailbox(): ?array
];
}
/**
* The landlord's active mailbox (at most one, CH-05).
*/
public function activeMailbox(): ?Mailbox
{
return Mailbox::query()->withoutGlobalScopes()->where('tenant_id', $this->id)->where('is_active', true)->orderBy('id')->first();
}
public function isLive(): bool
{
return $this->operating_mode === 'live';
+6 -3
View File
@@ -7,10 +7,11 @@
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* A service the operator switched on for a landlord. The own API key is optional and stored encrypted;
* an empty key means that the operator's key applies (no service calls it yet).
* A service the operator switched on for a landlord. A service that calls an external provider uses the landlord's
* own access (bring your own key, v0.11): the key is stored encrypted and never shown again; provider and models are
* in settings, the result of the last check beside them.
*/
#[Fillable(['tenant_id', 'service', 'is_enabled', 'api_key'])]
#[Fillable(['tenant_id', 'service', 'is_enabled', 'api_key', 'settings', 'check_status', 'check_message', 'checked_at'])]
class TenantService extends Model
{
/** @var list<string> */
@@ -24,6 +25,8 @@ protected function casts(): array
return [
'is_enabled' => 'boolean',
'api_key' => 'encrypted',
'settings' => 'array',
'checked_at' => 'immutable_datetime',
];
}
+16
View File
@@ -0,0 +1,16 @@
<?php
namespace App\Policies;
use App\Enums\Permission;
/**
* The inbox of guest messages belongs to handling the bookings.
*/
class InboundMessagePolicy extends RolePolicy
{
protected function permission(): Permission
{
return Permission::Bookings;
}
}
+102
View File
@@ -0,0 +1,102 @@
<?php
namespace App\Process;
use App\Enums\FactSource;
use App\Models\Booking;
use App\Models\BookingEvent;
use App\Models\CaseFact;
use Illuminate\Support\Collection;
/**
* What lies behind one step of the case's progress list: the history entries that belong to it and – for the guest's
* details – every detail with its source, time, evidence and certainty (v0.11, S5), so the landlord can see where a
* value came from and correct it.
*/
final class ActivityDetails
{
/** History types per step (the step's own key or its prefix). */
private const EVENT_TYPES = [
'intake' => ['created', 'intake', 'profile', 'hold', 'mode'],
'contact' => ['facts', 'fact', 'guest', 'data_request', 'mail_in'],
'data_request' => ['data_request', 'mail_in', 'facts', 'fact'],
'information' => ['information', 'mail', 'hold'],
'wish' => ['wish'],
'wish_check' => ['wish', 'status'],
'offer' => ['offer', 'hold', 'mail', 'status'],
'acceptance' => ['offer', 'status'],
'binding' => ['status', 'portal_signal'],
'price' => ['price', 'amount'],
'documents' => ['document', 'mail'],
'arrival_info' => ['document', 'mail'],
'review' => ['mail'],
'payment' => ['payment', 'amount'],
'deposit' => ['payment'],
'balance' => ['payment'],
'payout' => ['payment', 'amount'],
'change_proposed' => ['change'],
'arrival_details' => ['task', 'services'],
'stay' => ['task', 'services', 'status'],
'closure' => ['task', 'status', 'settled'],
'settlement' => ['settled'],
'task_' => ['task'],
];
public static function activity(Booking $booking, string $key): ?Activity
{
return collect(CaseActivities::for($booking))->first(fn (Activity $activity): bool => $activity->key === $key);
}
/**
* @return Collection<int, BookingEvent>
*/
public static function events(Booking $booking, string $key): Collection
{
$types = self::EVENT_TYPES[$key] ?? (str_starts_with($key, 'task_') ? self::EVENT_TYPES['task_'] : []);
return $types === [] ? collect() : $booking->events()->whereIn('type', $types)->reorder()->latest('occurred_at')->latest('id')->limit(50)->get();
}
public static function showsFacts(string $key): bool
{
return in_array($key, ['contact', 'data_request', 'intake'], true);
}
/**
* Every detail of the guest and the stay with its current value and where it came from (latest decisive fact).
*
* @return list<array{field: string, label: string, value: ?string, source: ?string, actor: ?string, at: ?string, evidence: ?string, confidence: ?float, open: list<string>}>
*/
public static function facts(Booking $booking): array
{
$facts = CaseFact::query()->where('booking_id', $booking->id)->orderBy('id')->get()->groupBy('field');
$rows = [];
foreach ([...CaseRequirements::FIELDS, ...CaseRequirements::OPTIONAL_FIELDS] as $field => $label) {
$value = CaseRequirements::value($booking, $field);
/** @var Collection<int, CaseFact> $history */
$history = $facts->get($field, collect());
$decisive = $history->reverse()->first(fn (CaseFact $fact): bool => in_array($fact->outcome, [CaseFact::APPLIED, CaseFact::CONFIRMED], true));
$open = $history->filter(fn (CaseFact $fact): bool => in_array($fact->outcome, [CaseFact::CONFLICT, CaseFact::CHANGE_REQUEST], true) && $fact->created_at->greaterThanOrEqualTo($decisive?->created_at ?? $fact->created_at))
->map(fn (CaseFact $fact): string => '„'.$fact->value.'“ laut '.$fact->source->getLabel().' – '.$fact->outcomeLabel())->values()->all();
if (blank($value) && $history->isEmpty()) {
continue;
}
$rows[] = [
'field' => $field,
'label' => $label,
'value' => filled($value) ? (string) $value : null,
'source' => $decisive?->source instanceof FactSource ? $decisive->source->getLabel() : (filled($value) ? 'vor der Herkunftsaufzeichnung erfasst' : null),
'actor' => $decisive?->actor,
'at' => $decisive?->created_at?->format('d.m.Y, H:i'),
'evidence' => $decisive?->evidence,
'confidence' => $decisive?->confidence,
'open' => $open,
];
}
return $rows;
}
}
Loaded 100 of 214 files, more files were not shown because too many files have changed in this diff. Show more