Ein Eingang fuer alle Kanaele (Paket 4, Prozessarchitektur v0.10)

Portalbuchungen und -anfragen aus Kalender und Mail werden ueber PortalIntake
zum Vorgang (nur bei sicherer Erkennung), Dubletten ueber Buchungsnummer,
gleiches Portal mit gleichen Naechten und Spiegelung; Unsicheres wird geklaert.
Portalstorno und -aenderung als Aufgabe am Vorgang ohne stille Stornierung.
Schalter je Kanal (Aus als Standard, Beobachten, Anlegen, Anlegen + weiter),
Eingangsprotokoll, Bestandsuebernahme mit Vorschau/Bericht/Ruecknahme,
Sperrnachweis in drei Stufen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Opus 5.5 committed 2026-11-01 20:53:35 +01:00
1 parent cf11c8a474
commit ac9d20b812
29 files changed
+1952 -16

No files matched your search

+489
View File
@@ -0,0 +1,489 @@
<?php
namespace App\Channels\Intake;
use App\Actions\ReconcileChannelRepresentations;
use App\Actions\TakeOverExternalBooking;
use App\Actions\TakeOverPortalInquiry;
use App\Channels\Mail\ParsedPortalMail;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\CaseIntakeMode;
use App\Enums\ChannelBookingModel;
use App\Enums\IntakeKind;
use App\Enums\IntakeOutcome;
use App\Enums\OccupationKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\Channel;
use App\Models\IntakeObservation;
use App\Models\PortalEmail;
use App\Pricing\QuoteException;
use App\Process\CaseLog;
use App\Process\ProcessSettings;
use Carbon\CarbonImmutable;
use Illuminate\Support\Collection;
use Throwable;
/**
* The one intake for bookings and requests from portals (UMSETZUNGSPLAN_v0.10 §5.5, package 4). Every incoming event –
* an entry of a portal calendar, a booking, request or cancellation e-mail – is judged the same way:
*
* - **Same case first** (no duplicates): an entry already linked to a case; the portal's booking reference; the same
* portal with exactly the same nights; the calendar mirror of an entry that belongs to a case. Different references
* or overlapping but different dates are never merged – they are clarified.
* - **New case only when certain**: a booking e-mail of the portal with dates and reference, or a calendar entry that
* the channel's rules recognise as a reservation booked at this portal (or that the landlord classified so). Blocks,
* mirrors of other portals, own use and unrecognised entries never become cases by themselves.
* - **Reports about known cases** (cancellation e-mail, entry gone from the calendar, other dates) become a task on the
* case and an entry in its history – the case itself is never cancelled, released or changed here (E-019).
*
* What happens then depends on the channel ({@see CaseIntakeMode}): nothing (off), only a record (observe), or the
* cases and tasks are created (create; continue additionally lets the new cases follow the automatic handling).
* Creating a case never sends anything the landlord did not release (package 3).
*/
class PortalIntake
{
public const LINK_NOTE = 'Automatisch dem Vorgang zugeordnet; der Vorgang führt diese Belegung.';
public function __construct(
private TakeOverExternalBooking $takeOver,
private TakeOverPortalInquiry $inquiry,
private ProcessSettings $settings,
) {}
/**
* Judges one portal calendar entry or e-mail block without changing anything.
*/
public function evaluate(BlockedPeriod $block): IntakeDecision
{
$block->loadMissing(['channel', 'property', 'canonicalBlock', 'linkedBooking']);
$channel = $block->channel;
$reference = self::reference($block);
if ($channel === null || ! in_array($block->source, ['channel', 'email'], true)) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Kein importierter Portaleintrag.'], reference: $reference);
}
if ($block->trashed()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Nicht mehr im Kalender des Portals.'], reference: $reference);
}
if ($block->linked_booking_id !== null && $block->linkedBooking !== null) {
return new IntakeDecision(IntakeOutcome::Link, ['Bereits dem Vorgang zugeordnet.'], $block->linkedBooking, reference: $reference);
}
if ($block->is_representation) {
$leaderCase = $block->canonicalBlock?->linkedBooking;
return $leaderCase !== null
? new IntakeDecision(IntakeOutcome::Link, ['Spiegelung einer Belegung, die zu diesem Vorgang gehört.'], $leaderCase, reference: $reference)
: new IntakeDecision(IntakeOutcome::Ignore, ['Spiegelung einer anderen Belegung, keine eigene Buchung.'], reference: $reference);
}
if ($reference !== null && ($case = $this->caseByReference($channel, $reference)) !== null) {
return new IntakeDecision(IntakeOutcome::Link, ['Gleiche Buchungsnummer '.$reference.' wie der Vorgang.'], $case, reference: $reference);
}
if ($block->ends_on->lessThanOrEqualTo(CarbonImmutable::today())) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Liegt in der Vergangenheit.'], reference: $reference);
}
if ($block->occupationKind() === OccupationKind::Block) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Als Sperrzeit eingeordnet (z. B. Spiegelung, eigene Nutzung oder Wartung).'], reference: $reference);
}
if ($block->is_private) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Als private Belegung eingeordnet.'], reference: $reference);
}
$origin = $block->origin_channel_id;
if ($origin !== null && $origin !== $channel->id) {
$case = $this->caseWithSameNights($block, $origin);
return $case !== null
? new IntakeDecision(IntakeOutcome::Link, ['Laut Kalender über ein anderes Portal gebucht; dort gibt es den Vorgang mit genau diesen Nächten.'], $case, reference: $reference)
: new IntakeDecision(IntakeOutcome::Clarify, ['Laut Kalender über ein anderes Portal gebucht – der Vorgang entsteht dort, nicht hier.'], reference: $reference);
}
$case = $this->caseWithSameNights($block, $channel->id);
if ($case !== null) {
return filled($case->portal_reference) && $reference !== null && $case->portal_reference !== $reference
? new IntakeDecision(IntakeOutcome::Clarify, ['Gleiche Nächte wie Vorgang '.$case->reference.', aber andere Buchungsnummer ('.$reference.' / '.$case->portal_reference.').'], reference: $reference)
: new IntakeDecision(IntakeOutcome::Link, ['Dasselbe Portal mit genau denselben Nächten wie Vorgang '.$case->reference.'.'], $case, reference: $reference);
}
$overlap = Booking::query()->occupying()->where('property_id', $block->property_id)->overlapping($block->starts_on, $block->ends_on)->first();
if ($overlap !== null) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Überschneidet sich mit Vorgang '.$overlap->reference.' ('.$overlap->arrival->format('d.m.').'–'.$overlap->departure->format('d.m.Y').'), ohne dieselbe Buchung zu sein.'], reference: $reference);
}
$sameChannelOverlap = $channel->blockedPeriods()->occupying()->whereKeyNot($block->id)->overlapping($block->starts_on, $block->ends_on)->exists();
if ($sameChannelOverlap) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Weitere Einträge desselben Portals überschneiden sich – keine Zusammenführung nach Terminen.'], reference: $reference);
}
$certainty = $this->certainty($block, $reference);
if ($certainty !== null) {
return new IntakeDecision(IntakeOutcome::Clarify, [$certainty], reference: $reference);
}
if ($channel->booking_model === ChannelBookingModel::Inquiry) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Über dieses Portal kommen laut Einstellung nur Anfragen – eine feste Buchung bitte bestätigen.'], reference: $reference);
}
$profile = $this->settings->resolve($block->property, $channel, IntakeKind::Booking);
$fields = (array) ($block->ical_interpretation['fields'] ?? []);
return new IntakeDecision(
IntakeOutcome::Create,
[$block->source === 'email' ? 'Buchungsmail von '.$channel->name.' mit Zeitraum und Buchungsnummer.' : 'Kalendereintrag nach Regel „'.($block->ical_interpretation['rule'] ?? 'persönlich eingeordnet').'“ als Buchung bei '.$channel->name.' erkannt.'],
caseType: $profile->caseType,
missing: array_values(array_filter([
blank($fields['guest_full_name'] ?? null) ? 'Name des Gastes' : 'Name des Gastes (nur als Hinweis aus dem Kalender)',
'E-Mail-Adresse des Gastes',
'Personenzahl',
'Gesamtpreis laut Portal',
$reference === null ? 'Buchungsnummer' : null,
])),
reference: $reference,
);
}
/**
* Judges an entry and acts as the channel allows: records what was recognised and – only when the channel creates
* cases – creates the case, links the entry to its case or marks it for clarification.
*/
public function process(BlockedPeriod $block, string $source): IntakeDecision
{
$channel = $block->channel;
$mode = $channel?->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Automatische Übernahme ist für dieses Portal aus.']);
}
$decision = $this->evaluate($block);
$applied = false;
if ($mode->creates()) {
[$decision, $applied] = match ($decision->outcome) {
IntakeOutcome::Create => $this->create($block, $decision, $mode, $source),
IntakeOutcome::Link => [$decision, $this->link($block, $decision->booking, $decision->reasons[0] ?? '')],
IntakeOutcome::Clarify => [$decision, $this->flag($block, $decision->reasons[0] ?? '')],
default => [$decision, false],
};
}
$this->record($channel, $mode, $source, $decision, $applied, $block, null, $block->starts_on, $block->ends_on);
return $decision;
}
/**
* Takes over an existing portal entry by an explicit run of the landlord or operator (stock adoption), whatever the
* channel's switch says: certain bookings become cases (released by hand, never automatic), entries of known cases
* are linked, everything else is only reported.
*/
public function adopt(BlockedPeriod $block): IntakeDecision
{
$decision = $this->evaluate($block);
$applied = false;
if ($decision->outcome === IntakeOutcome::Create) {
[$decision, $applied] = $this->create($block, $decision, CaseIntakeMode::Create, IntakeObservation::SOURCE_ADOPTION);
} elseif ($decision->outcome === IntakeOutcome::Link) {
$applied = $this->link($block, $decision->booking, $decision->reasons[0] ?? '');
}
$this->record($block->channel, CaseIntakeMode::Create, IntakeObservation::SOURCE_ADOPTION, $decision, $applied, $block, null, $block->starts_on, $block->ends_on);
return $decision;
}
/**
* After a calendar sync: new or changed entries of the channel go through the intake; entries of known cases that
* disappeared or show other nights become reports on the case.
*/
public function afterSync(Channel $channel): void
{
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return;
}
$open = $channel->blockedPeriods()->whereIn('source', ['channel', 'email'])->whereNull('linked_booking_id')
->where('is_representation', false)->whereDate('ends_on', '>', CarbonImmutable::today())->orderBy('starts_on')->get();
foreach ($open as $block) {
$this->process($block, IntakeObservation::SOURCE_CALENDAR);
}
$linked = $channel->blockedPeriods()->withTrashed()->with('linkedBooking')->where('source', 'channel')->whereNotNull('linked_booking_id')
->whereHas('linkedBooking', fn ($query) => $query->whereIn('status', BookingStatus::occupying())->whereDate('departure', '>', CarbonImmutable::today()))->get();
foreach ($linked as $block) {
$case = $block->linkedBooking;
if ($block->trashed()) {
$this->report($channel, $mode, $case, IntakeOutcome::CancellationSignal, 'Der Eintrag '.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').' ist aus dem Kalender von '.$channel->name.' verschwunden. Das kann eine Stornierung sein, ist aber kein Nachweis – bitte im Portal prüfen.', 'gone:'.$block->id, IntakeObservation::SOURCE_CALENDAR, $block);
} elseif (! $block->starts_on->equalTo($case->arrival) || ! $block->ends_on->equalTo($case->departure)) {
$this->report($channel, $mode, $case, IntakeOutcome::ChangeSignal, 'Der Kalender von '.$channel->name.' meldet '.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').', der Vorgang hat '.$case->arrival->format('d.m.').'–'.$case->departure->format('d.m.Y').'. Bitte prüfen, ob die Buchung im Portal geändert wurde.', 'dates:'.$block->id.':'.$block->starts_on->toDateString().':'.$block->ends_on->toDateString(), IntakeObservation::SOURCE_CALENDAR, $block);
}
}
}
/**
* A portal e-mail reporting a cancellation: the case learns about it as a task; nothing is cancelled.
*
* @return Booking|null the case the report belongs to
*/
public function cancellationMail(Channel $channel, ParsedPortalMail $parsed, PortalEmail $mail): ?Booking
{
$case = $parsed->reference !== null ? $this->caseByReference($channel, $parsed->reference) : null;
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if ($case === null || ! $case->isBinding()) {
$this->record($channel, $mode, IntakeObservation::SOURCE_MAIL, new IntakeDecision(IntakeOutcome::Clarify, [$parsed->reference === null ? 'Stornierungsmail ohne Buchungsnummer – keinem Vorgang sicher zuzuordnen.' : 'Kein gebuchter Vorgang mit der Buchungsnummer '.$parsed->reference.'.'], reference: $parsed->reference), false, null, $mail, $parsed->startsOn, $parsed->endsOn);
return null;
}
$this->report($channel, $mode, $case, IntakeOutcome::CancellationSignal, $channel->name.' meldet eine Stornierung (E-Mail „'.$mail->subject.'“). Bitte prüfen Sie die Buchung und die nächsten Schritte.', 'mail:'.$mail->message_id, IntakeObservation::SOURCE_MAIL, null, $mail);
return $case;
}
/**
* A request e-mail of a portal: a request case with the dates and the reference (A2), when the channel creates
* cases; otherwise only recorded.
*/
public function inquiryMail(Channel $channel, ParsedPortalMail $parsed, PortalEmail $mail): IntakeDecision
{
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Automatische Übernahme ist für dieses Portal aus.']);
}
$profile = $this->settings->resolve($channel->property, $channel, IntakeKind::Inquiry);
$decision = match (true) {
! $parsed->hasPeriod() => new IntakeDecision(IntakeOutcome::Clarify, ['Anfrage erkannt, aber An- und Abreise nicht sicher lesbar.'], reference: $parsed->reference),
$parsed->reference !== null && ($case = $this->caseByReference($channel, $parsed->reference)) !== null => new IntakeDecision(IntakeOutcome::Link, ['Gleiche Anfragenummer '.$parsed->reference.' wie der Vorgang.'], $case, reference: $parsed->reference),
$parsed->endsOn->lessThanOrEqualTo(CarbonImmutable::today()) => new IntakeDecision(IntakeOutcome::Ignore, ['Liegt in der Vergangenheit.'], reference: $parsed->reference),
default => new IntakeDecision(IntakeOutcome::Inquiry, ['Anfrage-Mail von '.$channel->name.' mit Zeitraum.'], caseType: $profile->caseType, missing: ['Name und E-Mail-Adresse des Gastes', 'Personenzahl'], reference: $parsed->reference),
};
$applied = false;
if ($mode->creates() && $decision->outcome === IntakeOutcome::Inquiry) {
try {
$case = $this->inquiry->handle($channel, $parsed->startsOn, $parsed->endsOn, $parsed->reference, 'Automatisch aus der Anfrage-Mail von '.$channel->name.' übernommen („'.$mail->subject.'“).', $mode === CaseIntakeMode::Create ? ProcessingMode::Manual : null);
CaseLog::record($case, 'intake', 'Automatisch aus der Anfrage-Mail von '.$channel->name.' angelegt', actor: CaseLog::SYSTEM, data: ['source' => IntakeObservation::SOURCE_MAIL, 'message_id' => $mail->message_id]);
$decision = $decision->withBooking($case);
$applied = true;
} catch (ReservationException|QuoteException $exception) {
$decision = $decision->as(IntakeOutcome::Clarify, ['Anfrage nicht automatisch übernommen: '.$exception->getMessage()]);
}
}
$this->record($channel, $mode, IntakeObservation::SOURCE_MAIL, $decision, $applied, null, $mail, $parsed->startsOn, $parsed->endsOn);
return $decision;
}
/**
* The portal's booking reference of an entry: extracted by the calendar rules, or the one of a booking e-mail.
*/
public static function reference(BlockedPeriod $block): ?string
{
$fromRules = $block->ical_interpretation['fields']['booking_reference'] ?? null;
if (filled($fromRules)) {
return trim((string) $fromRules);
}
if ($block->source === 'email' && str_starts_with((string) $block->external_uid, 'email:')) {
$reference = substr((string) $block->external_uid, 6);
// Mails without a reference got a random identifier, which is no booking reference.
return preg_match('/^[0-9a-f]{32}$/', $reference) === 1 ? null : $reference;
}
return null;
}
/**
* The case of a portal booking with this reference: on the case itself or on an entry that belongs to a case.
*/
public function caseByReference(Channel $channel, string $reference): ?Booking
{
$case = Booking::query()->where('portal_reference', $reference)
->where(fn ($query) => $query->where('origin_channel_id', $channel->id)->orWhere('import_channel_id', $channel->id))
->orderBy('id')->first();
if ($case !== null) {
return $case;
}
$linked = $channel->blockedPeriods()->withTrashed()->whereNotNull('linked_booking_id')
->whereIn('external_uid', [$reference, 'email:'.$reference])->value('linked_booking_id');
return $linked !== null ? Booking::query()->find($linked) : null;
}
/**
* The one occupying case of this portal with exactly these nights (more than one: none – that is for a person).
*/
private function caseWithSameNights(BlockedPeriod $block, int $channelId): ?Booking
{
/** @var Collection<int, Booking> $cases */
$cases = Booking::query()->occupying()->where('property_id', $block->property_id)
->whereDate('arrival', $block->starts_on)->whereDate('departure', $block->ends_on)
->where(fn ($query) => $query->where('origin_channel_id', $channelId)->orWhere('import_channel_id', $channelId))
->get();
return $cases->count() === 1 ? $cases->first() : null;
}
/**
* Null when the entry is certainly a booking of its portal, otherwise why not.
*/
private function certainty(BlockedPeriod $block, ?string $reference): ?string
{
if ($block->needs_review && ! in_array($block->review_note, [ReconcileChannelRepresentations::OVERLAP_NOTE], true)) {
return 'Prüfhinweis am Eintrag: '.($block->review_note ?? 'bitte prüfen').'.';
}
if ($block->source === 'email') {
return $reference === null ? 'Buchungsmail ohne Buchungsnummer – ohne Nummer lässt sich ein späterer Kalendereintrag nicht sicher zuordnen.' : null;
}
// Classified by the landlord as a reservation booked at this portal.
if ($block->occupation_kind === OccupationKind::Reservation && $block->reviewed_at !== null && $block->origin_channel_id === $block->channel_id) {
return null;
}
$interpretation = (array) ($block->ical_interpretation ?? []);
if (! ($interpretation['matched'] ?? false)) {
return 'Kein Kalendermerkmal erkannt – eine reine Belegt-Meldung ist kein Nachweis einer Buchung.';
}
if (($interpretation['event_type'] ?? null) !== 'portal_reservation') {
return 'Die Regel „'.($interpretation['rule'] ?? '').'“ ordnet den Eintrag nicht als Buchung ein.';
}
if (($interpretation['representation'] ?? null) !== 'leading_candidate' || $block->origin_channel_id !== $block->channel_id) {
return 'Die Regel erkennt eine Reservierung, aber nicht sicher als Buchung bei diesem Portal.';
}
return null;
}
/**
* @return array{IntakeDecision, bool}
*/
private function create(BlockedPeriod $block, IntakeDecision $decision, CaseIntakeMode $mode, string $source): array
{
$channel = $block->channel;
$fields = (array) ($block->ical_interpretation['fields'] ?? []);
$name = trim((string) ($fields['guest_full_name'] ?? $fields['guest_first_name'] ?? ''));
$origin = match ($source) {
IntakeObservation::SOURCE_MAIL => 'der Buchungsmail',
IntakeObservation::SOURCE_ADOPTION => 'dem Bestand der Portalbelegungen',
default => 'dem Kalender',
};
try {
$case = $this->takeOver->handle($block->property, $channel, CarbonImmutable::parse($block->starts_on), CarbonImmutable::parse($block->ends_on), [
'portal_reference' => $decision->reference,
'notes' => 'Automatisch aus '.$origin.' von '.$channel->name.' übernommen.'.($name !== '' ? ' Name laut Portal: '.$name.'.' : ''),
'processing_mode' => $mode === CaseIntakeMode::Create ? ProcessingMode::Manual : null,
], $block);
} catch (ReservationException $exception) {
$this->flag($block, 'Nicht automatisch übernommen: '.$exception->getMessage());
return [$decision->as(IntakeOutcome::Clarify, ['Nicht automatisch übernommen: '.$exception->getMessage()]), false];
}
CaseLog::record($case, 'intake', 'Automatisch aus '.$origin.' von '.$channel->name.' angelegt', actor: CaseLog::SYSTEM, data: ['source' => $source, 'blocked_period_id' => $block->id, 'reference' => $decision->reference]);
return [$decision->withBooking($case), true];
}
/**
* Makes the entry a mirror of its case (the case leads availability and export).
*/
private function link(BlockedPeriod $block, ?Booking $case, string $reason): bool
{
if ($case === null || $block->linked_booking_id === $case->id || $block->is_representation) {
return false;
}
$block->forceFill([
'is_representation' => true, 'representation_automatic' => false, 'canonical_block_id' => null,
'linked_booking_id' => $case->id, 'export_approved' => false, 'needs_review' => false, 'reviewed_at' => now(),
'occupation_kind' => OccupationKind::Reservation, 'review_note' => self::LINK_NOTE,
])->save();
app(ReconcileChannelRepresentations::class)->handle($block->property);
CaseLog::record($case, 'intake', 'Weitere Quelle zugeordnet: '.($block->source === 'email' ? 'E-Mail' : 'Kalender').' von '.$block->channel?->name.' ('.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').')', $reason, actor: CaseLog::SYSTEM, data: ['blocked_period_id' => $block->id]);
return true;
}
/**
* Puts an uncertain entry in front of the landlord ("Zu erledigen") with the reason.
*/
private function flag(BlockedPeriod $block, string $reason): bool
{
if ($block->needs_review || $block->reviewed_at !== null) {
return false;
}
$block->forceFill(['needs_review' => true, 'review_note' => mb_substr($reason, 0, 250)])->saveQuietly();
return true;
}
/**
* A report of the portal about a known case: a task and an entry in the history – once per report.
*/
private function report(Channel $channel, CaseIntakeMode $mode, Booking $case, IntakeOutcome $outcome, string $message, string $key, string $source, ?BlockedPeriod $block = null, ?PortalEmail $mail = null): void
{
$fingerprint = hash('sha256', $channel->id.'|signal|'.$key);
$known = $case->events()->where('type', 'portal_signal')->get()->contains(fn ($event): bool => ($event->data['fingerprint'] ?? null) === $fingerprint);
$applied = false;
if ($mode->creates() && ! $known) {
$kind = $outcome === IntakeOutcome::CancellationSignal ? BookingTaskKind::PortalCancellationReported : BookingTaskKind::PortalChangeReported;
$task = BookingTask::query()->firstOrNew(['booking_id' => $case->id, 'kind' => $kind]);
$task->forceFill(['tenant_id' => $case->tenant_id, 'status' => BookingTaskStatus::Open, 'due_on' => today(), 'note' => mb_substr($message, 0, 1000), 'completed_by' => null, 'completed_at' => null])->save();
CaseLog::record($case, 'portal_signal', $message, actor: $channel->name, data: ['fingerprint' => $fingerprint, 'source' => $source]);
$applied = true;
}
$this->record($channel, $mode, $source, new IntakeDecision($outcome, [$message], $case, $case->case_type), $applied, $block, $mail, $block?->starts_on ?? $case->arrival, $block?->ends_on ?? $case->departure, $key);
}
/**
* Records the decision once per event and result (repeated syncs and mails add nothing).
*/
private function record(?Channel $channel, CaseIntakeMode $mode, string $source, IntakeDecision $decision, bool $applied, ?BlockedPeriod $block, ?PortalEmail $mail, mixed $startsOn, mixed $endsOn, ?string $key = null): void
{
if ($channel === null || ! $mode->records()) {
return;
}
$fingerprint = hash('sha256', implode('|', [
$channel->id, $mode->value, $decision->outcome->value, $key ?? '',
$block?->id ?? '', $mail?->message_id ?? '', $decision->booking?->id ?? '',
$startsOn instanceof \DateTimeInterface ? $startsOn->format('Y-m-d') : (string) $startsOn,
$endsOn instanceof \DateTimeInterface ? $endsOn->format('Y-m-d') : (string) $endsOn,
]));
try {
$observation = IntakeObservation::query()->firstOrNew(['fingerprint' => $fingerprint]);
if ($observation->exists) {
return;
}
$observation->fill([
'channel_id' => $channel->id, 'blocked_period_id' => $block?->id, 'portal_email_id' => $mail?->id,
'booking_id' => $decision->booking?->id, 'source' => $source, 'mode' => $mode, 'outcome' => $decision->outcome,
'applied' => $applied, 'case_type' => $decision->caseType?->value, 'reference' => $decision->reference,
'starts_on' => $startsOn, 'ends_on' => $endsOn, 'reasons' => $decision->reasons, 'missing' => $decision->missing,
'occurred_at' => now(),
]);
$observation->tenant_id = $channel->tenant_id;
$observation->save();
} catch (Throwable $exception) {
// The record must never stop the intake itself.
report($exception);
}
}
}