507 lines
28 KiB
PHP
507 lines
28 KiB
PHP
<?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', 'api'], 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 report of the portal about a known case (channel events, Architektur V2: cancellation or change via an API):
|
||
* the case gets a task and a history entry, nothing about the booking changes (E-019, stage M2 of 02 §8.2).
|
||
*/
|
||
public function reportToCase(Channel $channel, Booking $case, IntakeOutcome $outcome, string $message, string $key, string $source): void
|
||
{
|
||
$this->report($channel, $channel->case_intake ?? CaseIntakeMode::Off, $case, $outcome, $message, $key, $source);
|
||
}
|
||
|
||
/**
|
||
* 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);
|
||
}
|
||
|
||
// A block of a portal's API (channel events, Architektur V2) carries the reference like a booking mail.
|
||
if ($block->source === 'api' && str_starts_with((string) $block->external_uid, 'api:')) {
|
||
return substr((string) $block->external_uid, 4);
|
||
}
|
||
|
||
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, 'api:'.$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;
|
||
}
|
||
if ($block->source === 'api') {
|
||
return $reference === null ? 'Portalmeldung ohne Buchungsnummer – keinem Vorgang sicher zuzuordnen.' : 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);
|
||
}
|
||
}
|
||
}
|