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 $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); } } }