diff --git a/app/Actions/ConfigureChannel.php b/app/Actions/ConfigureChannel.php new file mode 100644 index 0000000..ebff175 --- /dev/null +++ b/app/Actions/ConfigureChannel.php @@ -0,0 +1,46 @@ + $data */ + public function handle(Property $property, array $data, ?Channel $channel = null): Channel + { + return DB::transaction(function () use ($property, $data, $channel): Channel { + $stored = $channel ? $property->channels()->whereKey($channel->id)->lockForUpdate()->firstOrFail() : null; + $candidate = $stored ? clone $stored : new Channel; + $candidate->fill($data); + $candidate->property_id = $property->id; + $candidate->tenant_id = $property->tenant_id; + if ($stored) { + $candidate->is_active = $candidate->status === ChannelStatus::Active; + } + if ($candidate->import_enabled && blank($candidate->setting('import_url'))) { + throw ValidationException::withMessages(['settings.import_url' => 'Für einen aktivierten Import ist eine Kalenderadresse erforderlich.']); + } + if ($stored && $stored->setting('import_url') !== $candidate->setting('import_url') && $stored->blockedPeriods()->withTrashed()->exists()) { + throw ValidationException::withMessages(['settings.import_url' => 'Bei bestehendem Importbestand die Quelladresse nicht ungeprüft ersetzen. Einen neuen Kanal anlegen oder die Bestandsumstellung gesondert freigeben.']); + } + if ($stored && $stored->exportsOccupations() && ! $candidate->exportsOccupations() && $stored->export_snapshot === null) { + $body = app(ICalFeed::class)->build($stored); + app(ICalParser::class)->parse($body); + $candidate->forceFill(['export_snapshot' => $body, 'export_snapshot_at' => now()]); + } + if ($stored && $stored->importsOccupations() !== $candidate->importsOccupations()) { + $stored->blockedPeriods()->where('source', 'channel')->update(['missing_imports' => 0]); + } + $candidate->save(); + + return $candidate->refresh(); + }); + } +} diff --git a/app/Actions/CreateChannelTasks.php b/app/Actions/CreateChannelTasks.php index 1de7985..254ad65 100644 --- a/app/Actions/CreateChannelTasks.php +++ b/app/Actions/CreateChannelTasks.php @@ -2,12 +2,16 @@ namespace App\Actions; +use App\Availability\AvailabilityChecker; +use App\Enums\ChannelExportMode; use App\Enums\ChannelTaskAction; +use App\Enums\ChannelTaskStatus; use App\Mail\ChannelTasksNotification; use App\Models\Channel; use App\Models\ChannelTask; use App\Models\Property; use App\Support\Settings; +use Carbon\CarbonImmutable; use Carbon\CarbonInterface; use Illuminate\Support\Facades\Http; use Illuminate\Support\Facades\Mail; @@ -24,7 +28,7 @@ class CreateChannelTasks /** * @return list */ - public function handle(Property $property, CarbonInterface $startsOn, CarbonInterface $endsOn, ChannelTaskAction $action, string $reason, ?int $exceptChannelId = null): array + public function handle(Property $property, CarbonInterface $startsOn, CarbonInterface $endsOn, ChannelTaskAction $action, string $reason, ?int $exceptChannelId = null, ?int $originChannelId = null, bool $external = false): array { if ($endsOn->lessThanOrEqualTo(today())) { return []; @@ -33,14 +37,25 @@ public function handle(Property $property, CarbonInterface $startsOn, CarbonInte $channels = $property->channels()->active() ->where('requires_manual_blocking', true) ->when($exceptChannelId, fn ($query) => $query->whereKeyNot($exceptChannelId)) - ->get(); + ->when($originChannelId, fn ($query) => $query->whereKeyNot($originChannelId)) + ->get()->filter(fn (Channel $channel): bool => $channel->exportsOccupations() + && (! ($external || $exceptChannelId !== null || $originChannelId !== null) || $channel->export_mode === ChannelExportMode::Regular)); - $tasks = $channels->map(fn (Channel $channel): ChannelTask => $channel->tasks()->create([ - 'action' => $action, - 'starts_on' => $startsOn->toDateString(), - 'ends_on' => $endsOn->toDateString(), - 'reason' => $reason, - ]))->all(); + $tasks = []; + foreach ($channels as $channel) { + $segments = $action === ChannelTaskAction::Unblock ? $this->freeSegments($property, $startsOn, $endsOn) : [[$startsOn, $endsOn]]; + foreach ($segments as [$start, $end]) { + $task = $channel->tasks()->where('action', $action)->where('status', ChannelTaskStatus::Open) + ->whereDate('starts_on', $start)->whereDate('ends_on', $end)->first() + ?? $channel->tasks()->create([ + 'action' => $action, 'starts_on' => $start->toDateString(), 'ends_on' => $end->toDateString(), + 'status' => ChannelTaskStatus::Open, 'reason' => $reason, + ]); + if ($task->wasRecentlyCreated) { + $tasks[] = $task; + } + } + } if ($tasks === []) { return []; @@ -61,6 +76,30 @@ public function handle(Property $property, CarbonInterface $startsOn, CarbonInte */ public function sendToAutomation(ChannelTask $task): void { + $task->refresh(); + if ($task->status !== ChannelTaskStatus::Open) { + return; + } + if (! $task->channel->exportsOccupations()) { + $task->update(['automation_error' => 'Kanalexport ist pausiert; keine automatische Portaländerung.']); + + return; + } + if ($task->action === ChannelTaskAction::Unblock && ! app(AvailabilityChecker::class)->isAvailable($task->channel->property, $task->starts_on, $task->ends_on)) { + $task->update(['status' => ChannelTaskStatus::Dismissed, 'automation_error' => 'Zeitraum ist inzwischen wieder belegt; nicht entsperren.']); + + return; + } + if ($task->action === ChannelTaskAction::Block) { + $occupied = app(AvailabilityChecker::class)->occupiedNights($task->channel->property, $task->starts_on, $task->ends_on); + for ($night = $task->starts_on; $night->lessThan($task->ends_on); $night = $night->addDay()) { + if (! isset($occupied[$night->toDateString()])) { + $task->update(['status' => ChannelTaskStatus::Dismissed, 'automation_error' => 'Sperraufgabe ist durch eine Belegungsänderung überholt; aktuellen Zeitraum prüfen.']); + + return; + } + } + } $url = config('fewo.automation.webhook_url'); $secret = config('fewo.automation.secret'); if (blank($url) || blank($secret)) { @@ -90,4 +129,27 @@ public function sendToAutomation(ChannelTask $task): void $task->update(['automation_error' => $exception->getMessage()]); } } + + /** @return list */ + private function freeSegments(Property $property, CarbonInterface $startsOn, CarbonInterface $endsOn): array + { + $start = CarbonImmutable::instance($startsOn); + $end = CarbonImmutable::instance($endsOn); + $occupied = app(AvailabilityChecker::class)->occupiedNights($property, $start, $end); + $segments = []; + $segmentStart = null; + for ($night = $start; $night->lessThan($end); $night = $night->addDay()) { + if (! isset($occupied[$night->toDateString()])) { + $segmentStart ??= $night; + } elseif ($segmentStart !== null) { + $segments[] = [$segmentStart, $night]; + $segmentStart = null; + } + } + if ($segmentStart !== null) { + $segments[] = [$segmentStart, $end]; + } + + return $segments; + } } diff --git a/app/Actions/ProcessPortalMail.php b/app/Actions/ProcessPortalMail.php index 7a2412a..f038996 100644 --- a/app/Actions/ProcessPortalMail.php +++ b/app/Actions/ProcessPortalMail.php @@ -93,7 +93,7 @@ public function channelFor(string $from): ?Channel { $from = mb_strtolower($from); - return Channel::query()->active()->get()->first(function (Channel $channel) use ($from): bool { + $matches = Channel::query()->active()->get()->filter(function (Channel $channel) use ($from): bool { foreach ($this->senders($channel) as $sender) { if (str_contains($from, $sender)) { return true; @@ -102,6 +102,16 @@ public function channelFor(string $from): ?Channel return false; }); + + if ($matches->count() > 1) { + foreach ($matches as $channel) { + $channel->forceFill(['sync_warnings' => array_values(array_unique([ + ...($channel->sync_warnings ?? []), 'Portal-Mail-Absender passt zu mehreren Kanälen. Keine automatische Wohnungszuordnung vorgenommen.', + ]))])->saveQuietly(); + } + } + + return $matches->count() === 1 ? $matches->first() : null; } /** @@ -125,11 +135,13 @@ private function block(Channel $channel, ParsedPortalMail $parsed, array &$confl return [PortalEmailStatus::NeedsReview, null, 'Buchung erkannt, aber An-/Abreise nicht sicher lesbar.']; } - $known = $channel->blockedPeriods() - ->whereDate('starts_on', $parsed->startsOn) - ->whereDate('ends_on', $parsed->endsOn) - ->first(); + $known = $parsed->reference === null ? null : $channel->blockedPeriods() + ->whereIn('external_uid', ['email:'.$parsed->reference, $parsed->reference])->first(); if ($known) { + if ($known->source === 'email') { + $known->update(['starts_on' => $parsed->startsOn->toDateString(), 'ends_on' => $parsed->endsOn->toDateString()]); + } + return [PortalEmailStatus::AlreadyKnown, $known, null]; } @@ -139,9 +151,13 @@ private function block(Channel $channel, ParsedPortalMail $parsed, array &$confl 'ends_on' => $parsed->endsOn->toDateString(), 'reason' => "{$channel->name} (E-Mail)".($parsed->reference ? ": {$parsed->reference}" : ''), 'source' => 'email', - 'external_uid' => 'email:'.($parsed->reference ?? $parsed->startsOn->format('Ymd').'-'.$parsed->endsOn->format('Ymd')), + 'external_uid' => 'email:'.($parsed->reference ?? bin2hex(random_bytes(16))), ]); + if ($channel->blockedPeriods()->whereKeyNot($block->id)->overlapping($block->starts_on, $block->ends_on)->exists()) { + $block->forceFill(['needs_review' => true, 'review_note' => 'Überlappende Portalrepräsentationen ohne gemeinsame Kennung persönlich prüfen.'])->saveQuietly(); + } + $conflicts = $this->conflictDetector->conflictsFor($block); return [PortalEmailStatus::Blocked, $block, null]; @@ -158,7 +174,6 @@ private function release(Channel $channel, ParsedPortalMail $parsed): array $block = match (true) { $parsed->reference !== null => (clone $emailBlocks)->where('external_uid', 'email:'.$parsed->reference)->first(), - $parsed->hasPeriod() => (clone $emailBlocks)->whereDate('starts_on', $parsed->startsOn)->whereDate('ends_on', $parsed->endsOn)->first(), default => null, }; diff --git a/app/Actions/ResolveChannelOccupation.php b/app/Actions/ResolveChannelOccupation.php new file mode 100644 index 0000000..c7b8853 --- /dev/null +++ b/app/Actions/ResolveChannelOccupation.php @@ -0,0 +1,50 @@ +whereKey($block->id)->lockForUpdate()->firstOrFail(); + if (! in_array($block->source, ['channel', 'email'], true)) { + throw ValidationException::withMessages(['resolution' => 'Nur importierte Portalereignisse benötigen diese Zuordnung.']); + } + if (! in_array($resolution, ['independent', 'block', 'booking'], true)) { + throw ValidationException::withMessages(['resolution' => 'Bitte eine gültige Klärung wählen.']); + } + if ($originId !== null && ! Channel::query()->whereKey($originId)->where('property_id', $block->property_id)->exists()) { + throw ValidationException::withMessages(['origin_channel_id' => 'Der Ursprungskanal muss zur selben Wohnung gehören.']); + } + $attributes = ['is_representation' => false, 'canonical_block_id' => null, 'linked_booking_id' => null, + 'origin_channel_id' => $originId, 'export_approved' => true, 'needs_review' => false, + 'reviewed_at' => now(), 'review_note' => 'Als eigenständige Belegung persönlich bestätigt.']; + if ($resolution !== 'independent') { + $query = $resolution === 'booking' ? Booking::query()->occupying() : BlockedPeriod::query()->occupying()->whereKeyNot($block->id); + $target = $query->where('property_id', $block->property_id)->whereKey($targetId)->lockForUpdate()->first(); + $start = $resolution === 'booking' ? $target?->arrival : $target?->starts_on; + $end = $resolution === 'booking' ? $target?->departure : $target?->ends_on; + if ($target === null || ! $block->starts_on->equalTo($start) || ! $block->ends_on->equalTo($end)) { + throw ValidationException::withMessages(['target_id' => 'Eine belegende Buchung oder führende Sperre derselben Wohnung mit genau diesem Zeitraum wählen.']); + } + if (BlockedPeriod::query()->where('canonical_block_id', $block->id)->exists()) { + throw ValidationException::withMessages(['target_id' => 'Diese Sperre führt bereits andere Kalenderdarstellungen. Die Zuordnung an der untergeordneten Darstellung ändern.']); + } + $attributes = [...$attributes, 'is_representation' => true, 'export_approved' => false, + 'canonical_block_id' => $resolution === 'block' ? $target->id : null, + 'linked_booking_id' => $resolution === 'booking' ? $target->id : null, + 'review_note' => 'Persönlich zugeordnet; nur die führende Belegung steuert Verfügbarkeit und Export.']; + } + $block->update($attributes); + + return $block->refresh(); + }); + } +} diff --git a/app/Actions/RotateChannelToken.php b/app/Actions/RotateChannelToken.php new file mode 100644 index 0000000..efb7483 --- /dev/null +++ b/app/Actions/RotateChannelToken.php @@ -0,0 +1,28 @@ +whereKey($channel->id)->lockForUpdate()->firstOrFail(); + if ($graceHours < 24 || $graceHours > 720 || $locked->previous_export_token_expires_at?->isFuture()) { + throw ValidationException::withMessages(['grace_hours' => '24 bis 720 Stunden wählen; eine laufende Token-Übergangsphase muss zuerst ablaufen.']); + } + $locked->forceFill([ + 'previous_export_token' => $locked->export_token, + 'previous_export_token_expires_at' => now()->addHours($graceHours), + 'export_token' => Str::random(48), + ])->save(); + + return $locked->refresh(); + }); + } +} diff --git a/app/Actions/SyncChannel.php b/app/Actions/SyncChannel.php index 8733547..bc9d591 100644 --- a/app/Actions/SyncChannel.php +++ b/app/Actions/SyncChannel.php @@ -5,19 +5,20 @@ use App\Channels\ChannelSyncException; use App\Channels\ConflictDetector; use App\Channels\ExternalPeriod; +use App\Enums\ChannelEchoBehavior; use App\Mail\ChannelConflict; use App\Models\BlockedPeriod; +use App\Models\Booking; use App\Models\Channel; use App\Models\ChannelSyncLog; +use App\Models\Property; use App\Support\Settings; use Carbon\CarbonImmutable; +use Illuminate\Support\Facades\Cache; use Illuminate\Support\Facades\DB; use Illuminate\Support\Facades\Mail; -/** - * Imports the occupations of one portal as blocked periods and reports overlaps with - * occupations from anywhere else immediately (possible double booking). - */ +/** Imports one complete channel snapshot without guessing that overlapping events are identical. */ class SyncChannel { public function __construct(private ConflictDetector $conflictDetector = new ConflictDetector) {} @@ -25,105 +26,120 @@ public function __construct(private ConflictDetector $conflictDetector = new Con public function handle(Channel $channel): ChannelSyncLog { $startedAt = microtime(true); - - try { - $periods = $channel->connector()->fetchOccupations($channel); - } catch (ChannelSyncException $exception) { - $channel->forceFill(['last_synced_at' => now(), 'last_error' => $exception->getMessage()])->save(); - - return $channel->syncLogs()->create([ - 'successful' => false, - 'message' => $exception->getMessage(), - 'duration_ms' => $this->elapsed($startedAt), - ]); + $lock = Cache::lock("channel-sync:{$channel->tenant_id}:{$channel->id}", 120); + if (! $lock->get()) { + return $channel->syncLogs()->create(['successful' => false, 'message' => 'Für diesen Kanal läuft bereits ein Abgleich.']); } - - $today = CarbonImmutable::today(); - $suffix = config('channels.uid_suffix'); - $periods = array_values(array_filter( - $periods, - fn (ExternalPeriod $period): bool => $period->endsOn->greaterThan($today) && ! str_ends_with($period->uid, $suffix), - )); - - $counts = ['added' => 0, 'changed' => 0, 'removed' => 0]; - $conflicts = []; - - DB::transaction(function () use ($channel, $periods, $today, &$counts, &$conflicts): void { - $existing = $channel->blockedPeriods()->where('source', 'channel')->get()->keyBy('external_uid'); - $fromEmails = $channel->blockedPeriods()->where('source', 'email')->get(); - $seen = []; - - foreach ($periods as $period) { - $seen[$period->uid] = true; - $block = $existing->get($period->uid); - - if ($block && $block->starts_on->equalTo($period->startsOn) && $block->ends_on->equalTo($period->endsOn)) { - continue; + try { + $channel->refresh(); + if (! $channel->importsOccupations()) { + return $channel->syncLogs()->create(['successful' => false, 'message' => 'Import ist pausiert oder noch nicht eingerichtet.']); + } + $importUrl = $channel->setting('import_url'); + $periods = $channel->connector()->fetchOccupations($channel); + $suffix = config('channels.uid_suffix'); + if (! is_string($suffix) || $suffix === '') { + throw new ChannelSyncException('Der UID-Echofilter ist nicht eingerichtet.'); + } + $today = CarbonImmutable::today(); + $periods = array_values(array_filter($periods, fn (ExternalPeriod $period): bool => $period->endsOn->greaterThan($today) && ! str_ends_with($period->uid, $suffix))); + $counts = ['added' => 0, 'changed' => 0, 'removed' => 0]; + $warnings = []; + $conflicts = []; + DB::transaction(function () use ($channel, $periods, $importUrl, $today, &$counts, &$warnings, &$conflicts): void { + $locked = Channel::query()->whereKey($channel->id)->lockForUpdate()->firstOrFail(); + if (! $locked->importsOccupations() || $locked->setting('import_url') !== $importUrl) { + throw new ChannelSyncException('Die Kanalkonfiguration wurde während des Abrufs geändert.'); } - - $attributes = [ - 'property_id' => $channel->property_id, - 'starts_on' => $period->startsOn->toDateString(), - 'ends_on' => $period->endsOn->toDateString(), - // The portal's SUMMARY is not stored: it may contain guest names (data minimisation). - 'reason' => $channel->name, - 'source' => 'channel', - ]; - - $confirmedEmailBlock = $block ? null : $fromEmails->first(fn (BlockedPeriod $emailBlock): bool => $emailBlock->starts_on->equalTo($period->startsOn) && $emailBlock->ends_on->equalTo($period->endsOn)); - - if ($confirmedEmailBlock) { - // Already blocked from the portal's e-mail; the calendar only confirms it. - $confirmedEmailBlock->update([...$attributes, 'external_uid' => $period->uid]); - $fromEmails = $fromEmails->reject(fn (BlockedPeriod $emailBlock): bool => $emailBlock->is($confirmedEmailBlock)); - $counts['changed']++; - - continue; + Property::query()->whereKey($channel->property_id)->lockForUpdate()->firstOrFail(); + $rows = $channel->blockedPeriods()->withTrashed()->where('source', 'channel')->get(); + if ($rows->groupBy('external_uid')->contains(fn ($group): bool => $group->count() > 1) || $rows->contains(fn (BlockedPeriod $block): bool => blank($block->external_uid))) { + throw new ChannelSyncException('Vorhandene Kalender-Dubletten oder fehlende UIDs benötigen eine manuelle Prüfung. Der Bestand bleibt erhalten.'); } - - if ($block) { - $block->update($attributes); - $counts['changed']++; + $existing = $rows->keyBy('external_uid'); + $emails = $channel->blockedPeriods()->where('source', 'email')->get(); + $seen = []; + foreach ($periods as $period) { + $seen[$period->uid] = true; + $block = $existing->get($period->uid); + $matchedMail = $block ? null : $emails->firstWhere('external_uid', 'email:'.$period->uid); + $attributes = ['property_id' => $channel->property_id, 'starts_on' => $period->startsOn->toDateString(), + 'ends_on' => $period->endsOn->toDateString(), 'reason' => $channel->name, 'source' => 'channel', + 'external_uid' => $period->uid, 'missing_imports' => 0]; + if ($matchedMail) { + $block = $matchedMail; + $block->update($attributes); + $emails = $emails->reject(fn (BlockedPeriod $mail): bool => $mail->is($block)); + $counts['changed']++; + } elseif ($block) { + if ($block->trashed()) { + $block->fill($attributes)->restore(); + $counts['added']++; + } elseif (! $block->starts_on->equalTo($period->startsOn) || ! $block->ends_on->equalTo($period->endsOn)) { + $block->update($attributes); + $counts['changed']++; + } elseif ($block->missing_imports !== 0) { + $block->forceFill(['missing_imports' => 0])->saveQuietly(); + } + } else { + $overlap = $channel->property->blockedPeriods()->occupying()->overlapping($period->startsOn, $period->endsOn)->exists() + || $channel->property->bookings()->occupying()->overlapping($period->startsOn, $period->endsOn)->exists(); + $attributes['export_approved'] = ! $overlap && $locked->echo_behavior !== ChannelEchoBehavior::Reexports; + $block = $channel->blockedPeriods()->create($attributes); + $counts['added']++; + } + $existing->put($period->uid, $block); + $overlap = $channel->blockedPeriods()->occupying()->overlapping($block->starts_on, $block->ends_on)->whereKeyNot($block->id)->exists(); + $foundConflicts = $block->is_representation ? [] : $this->conflictDetector->conflictsFor($block); + $linked = $block->canonicalBlock ?? $block->linkedBooking; + $linkedStart = $linked instanceof Booking ? $linked->arrival : $linked?->starts_on; + $linkedEnd = $linked instanceof Booking ? $linked->departure : $linked?->ends_on; + $representationChanged = $block->is_representation && ($linked === null || ! $block->starts_on->equalTo($linkedStart) || ! $block->ends_on->equalTo($linkedEnd)); + if ($representationChanged || (! $block->is_representation && $block->reviewed_at === null && ($overlap || $emails->isNotEmpty() || $foundConflicts !== [] || ! $block->export_approved))) { + $note = 'Mehrere Belegungsrepräsentationen oder Überschneidungen prüfen; keine automatische Zusammenführung anhand von Terminen.'; + $block->forceFill(['needs_review' => true, 'review_note' => $note])->saveQuietly(); + foreach ($emails as $mailBlock) { + $mailBlock->forceFill(['needs_review' => true, 'review_note' => $note])->saveQuietly(); + } + $warnings[] = $note; + } + array_push($conflicts, ...$foundConflicts); + } + $missing = $rows->filter(fn (BlockedPeriod $block): bool => ! $block->trashed() && ! isset($seen[$block->external_uid]) && $block->ends_on->greaterThan($today)); + if ($missing->count() > config('channels.max_automatic_removals', 5)) { + $warnings[] = 'Ungewöhnlich viele Ereignisse fehlen. Keine automatische Entfernung; Portalkalender persönlich prüfen.'; + foreach ($missing as $block) { + $block->forceFill(['needs_review' => true, 'review_note' => end($warnings)])->saveQuietly(); + } } else { - $block = $channel->blockedPeriods()->create([...$attributes, 'external_uid' => $period->uid]); - $counts['added']++; + foreach ($missing as $block) { + $block->increment('missing_imports'); + if ($block->missing_imports >= config('channels.removal_confirmation_runs', 2)) { + $block->delete(); + $counts['removed']++; + } else { + $warnings[] = 'Fehlende Ereignisse bleiben bis zum nächsten bestätigenden Kalenderstand gesperrt.'; + } + } } - - // E-mail blocks of this portal overlapping the calendar entry describe the same booking with deviating dates. - $superseded = $fromEmails->filter(fn (BlockedPeriod $emailBlock): bool => $emailBlock->starts_on->lessThan($block->ends_on) && $emailBlock->ends_on->greaterThan($block->starts_on)); - $superseded->each->delete(); - $fromEmails = $fromEmails->diff($superseded); - - array_push($conflicts, ...$this->conflictDetector->conflictsFor($block)); + $warnings = array_values(array_unique($warnings)); + $locked->forceFill(['last_synced_at' => now(), 'last_success_at' => now(), 'last_error' => null, + 'alerted_at' => null, 'last_import_events' => count($periods), 'sync_warnings' => $warnings])->save(); + }); + if ($conflicts !== []) { + rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new ChannelConflict($channel, array_values(array_unique($conflicts))))); } - $stale = $existing->reject(fn (BlockedPeriod $block, string $uid): bool => isset($seen[$uid]) || $block->ends_on->lessThanOrEqualTo($today)); - $stale->each->delete(); - $counts['removed'] = $stale->count(); - }); + return $channel->syncLogs()->create(['successful' => true, 'events' => count($periods), ...$counts, + 'conflicts' => count(array_unique($conflicts)), 'warnings' => $warnings, + 'duration_ms' => (int) round((microtime(true) - $startedAt) * 1000)]); + } catch (ChannelSyncException $exception) { + $channel->forceFill(['last_synced_at' => now(), 'last_error_at' => now(), 'last_error' => $exception->getMessage()])->save(); - $channel->forceFill([ - 'last_synced_at' => now(), - 'last_success_at' => now(), - 'last_error' => null, - 'alerted_at' => null, - ])->save(); - - if ($conflicts !== []) { - rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new ChannelConflict($channel, $conflicts))); + return $channel->syncLogs()->create(['successful' => false, 'message' => $exception->getMessage(), + 'duration_ms' => (int) round((microtime(true) - $startedAt) * 1000)]); + } finally { + $lock->release(); } - - return $channel->syncLogs()->create([ - 'successful' => true, - 'events' => count($periods), - ...$counts, - 'conflicts' => count($conflicts), - 'duration_ms' => $this->elapsed($startedAt), - ]); - } - - private function elapsed(float $startedAt): int - { - return (int) round((microtime(true) - $startedAt) * 1000); } } diff --git a/app/Availability/AvailabilityChecker.php b/app/Availability/AvailabilityChecker.php index 72163f3..8d6051e 100644 --- a/app/Availability/AvailabilityChecker.php +++ b/app/Availability/AvailabilityChecker.php @@ -21,7 +21,7 @@ public function isAvailable(Property $property, CarbonImmutable $from, CarbonImm ->when($ignore, fn ($query) => $query->whereKeyNot($ignore->getKey())) ->exists(); - return ! $bookingConflict && ! $property->blockedPeriods()->overlapping($from, $until)->exists(); + return ! $bookingConflict && ! $property->blockedPeriods()->occupying()->overlapping($from, $until)->exists(); } /** @@ -33,7 +33,7 @@ public function occupiedNights(Property $property, CarbonImmutable $from, Carbon { $periods = $property->bookings()->occupying()->overlapping($from, $until)->get(['arrival', 'departure']) ->map(fn (Booking $booking): array => [$booking->arrival, $booking->departure]) - ->concat($property->blockedPeriods()->overlapping($from, $until)->get(['starts_on', 'ends_on']) + ->concat($property->blockedPeriods()->occupying()->overlapping($from, $until)->get(['starts_on', 'ends_on']) ->map(fn (BlockedPeriod $period): array => [$period->starts_on, $period->ends_on])); $nights = []; diff --git a/app/Channels/ConflictDetector.php b/app/Channels/ConflictDetector.php index b232122..b704a77 100644 --- a/app/Channels/ConflictDetector.php +++ b/app/Channels/ConflictDetector.php @@ -24,6 +24,7 @@ public function conflictsFor(BlockedPeriod $block): array ->map(fn (Booking $booking): string => "{$channelName} meldet {$period}, überschneidet sich mit Buchung {$booking->reference} ({$booking->guest->full_name}, {$booking->arrival->format('d.m.Y')} – {$booking->departure->format('d.m.Y')})"); $blocks = $property->blockedPeriods() + ->occupying() ->overlapping($block->starts_on, $block->ends_on) ->whereKeyNot($block->getKey()) ->when($block->channel_id, fn ($query) => $query->where(fn ($query) => $query->whereNull('channel_id')->orWhere('channel_id', '!=', $block->channel_id))) diff --git a/app/Channels/ICal/ICalConnector.php b/app/Channels/ICal/ICalConnector.php index bb384ca..3a61d75 100644 --- a/app/Channels/ICal/ICalConnector.php +++ b/app/Channels/ICal/ICalConnector.php @@ -32,9 +32,11 @@ public static function settingsSchema(): array { return [ TextInput::make('settings.import_url') - ->label('iCal-Export-Adresse des Portals') + ->label('Importadresse: iCal-Export des externen Portals') ->helperText('Im Vermieterbereich des Portals unter „Kalender exportieren“. Leer lassen, wenn das Portal keinen Kalender anbietet.') ->url() + ->password() + ->revealable() ->maxLength(2048), ]; } @@ -55,7 +57,7 @@ public function fetchOccupations(Channel $channel): array ->get($url) ->throw(); } catch (ConnectionException|RequestException $exception) { - throw new ChannelSyncException('Kalender konnte nicht abgerufen werden: '.$exception->getMessage(), previous: $exception); + throw new ChannelSyncException('Kalender konnte nicht abgerufen werden. Netzwerkverbindung und Portaladresse prüfen.', previous: $exception); } return $this->parser->parse($response->body()); diff --git a/app/Channels/ICal/ICalExport.php b/app/Channels/ICal/ICalExport.php new file mode 100644 index 0000000..5a0de9e --- /dev/null +++ b/app/Channels/ICal/ICalExport.php @@ -0,0 +1,26 @@ +whereKey($channel->id)->lockForUpdate()->firstOrFail(); + if ($locked->exportsOccupations()) { + $body = $this->feed->build($locked); + $this->parser->parse($body); + $locked->forceFill(['export_snapshot' => $body, 'export_snapshot_at' => now()]); + } + $locked->forceFill(['last_export_requested_at' => now()])->saveQuietly(); + + return $locked->export_snapshot; + }); + } +} diff --git a/app/Channels/ICal/ICalFeed.php b/app/Channels/ICal/ICalFeed.php index 591586a..66e563c 100644 --- a/app/Channels/ICal/ICalFeed.php +++ b/app/Channels/ICal/ICalFeed.php @@ -2,6 +2,7 @@ namespace App\Channels\ICal; +use App\Enums\ChannelExportMode; use App\Models\Booking; use App\Models\Channel; use Carbon\CarbonImmutable; @@ -23,21 +24,32 @@ public function build(Channel $channel): string $events = []; - foreach ($property->bookings()->occupying()->overlapping($from, $until)->get() as $booking) { + $bookings = $property->bookings()->occupying()->overlapping($from, $until); + if ($channel->export_mode === ChannelExportMode::Test) { + $bookings->whereNull('import_channel_id')->whereNull('origin_channel_id')->whereIn('source', Booking::DIRECT_SOURCES); + } else { + $bookings->where(fn ($query) => $query->whereNull('import_channel_id')->orWhere('import_channel_id', '!=', $channel->id)) + ->where(fn ($query) => $query->whereNull('origin_channel_id')->orWhere('origin_channel_id', '!=', $channel->id)); + } + foreach ($bookings->orderBy('id')->get() as $booking) { /** @var Booking $booking */ $events[] = $this->event("booking-{$booking->id}{$suffix}", $booking->arrival, $booking->departure, $booking->updated_at); } $blocks = $property->blockedPeriods() + ->occupying()->where('export_approved', true) ->overlapping($from, $until) ->where(fn ($query) => $query->whereNull('channel_id')->orWhere('channel_id', '!=', $channel->id)) - ->get(); + ->where(fn ($query) => $query->whereNull('origin_channel_id')->orWhere('origin_channel_id', '!=', $channel->id)); + if ($channel->export_mode === ChannelExportMode::Test) { + $blocks->whereNull('channel_id')->whereNull('origin_channel_id')->where('source', 'manual'); + } - foreach ($blocks as $block) { + foreach ($blocks->orderBy('id')->get() as $block) { $events[] = $this->event("block-{$block->id}{$suffix}", $block->starts_on, $block->ends_on, $block->updated_at); } - return implode("\r\n", [ + $lines = [ 'BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//Ferienwohnung Stommer//Belegung//DE', @@ -46,7 +58,9 @@ public function build(Channel $channel): string 'X-WR-CALNAME:'.$this->escape($property->name), ...$events, 'END:VCALENDAR', - ])."\r\n"; + ]; + + return implode("\r\n", array_map(fn (string $line): string => $this->fold($line), explode("\r\n", implode("\r\n", $lines))))."\r\n"; } private function event(string $uid, CarbonInterface $start, CarbonInterface $end, ?CarbonInterface $modified): string @@ -65,6 +79,21 @@ private function event(string $uid, CarbonInterface $start, CarbonInterface $end private function escape(string $text): string { - return str_replace(['\\', ';', ',', "\n"], ['\\\\', '\\;', '\\,', '\\n'], $text); + return str_replace(['\\', ';', ',', "\n"], ['\\\\', '\\;', '\\,', '\\n'], str_replace(["\r\n", "\r"], "\n", $text)); + } + + private function fold(string $line): string + { + $parts = []; + $limit = 75; + while (strlen($line) > $limit) { + $part = mb_strcut($line, 0, $limit, 'UTF-8'); + $parts[] = $part; + $line = substr($line, strlen($part)); + $limit = 74; + } + $parts[] = $line; + + return implode("\r\n ", $parts); } } diff --git a/app/Channels/ICal/ICalParser.php b/app/Channels/ICal/ICalParser.php index f47779a..b4e0d58 100644 --- a/app/Channels/ICal/ICalParser.php +++ b/app/Channels/ICal/ICalParser.php @@ -5,117 +5,204 @@ use App\Channels\ChannelSyncException; use App\Channels\ExternalPeriod; use Carbon\CarbonImmutable; +use Throwable; -/** - * Minimal RFC 5545 reader for availability feeds: VEVENTs with DTSTART/DTEND (date or date-time), - * UID and SUMMARY. Cancelled events and events without a positive length are skipped. - */ +/** Complete non-recurring availability snapshots; damaged feeds never become deletions. */ class ICalParser { - /** - * @return list - * - * @throws ChannelSyncException - */ + /** @return list */ public function parse(string $ics): array { - if (! str_contains($ics, 'BEGIN:VCALENDAR')) { - throw new ChannelSyncException('Die Antwort ist kein iCal-Kalender.'); + if (str_starts_with($ics, "\xEF\xBB\xBF")) { + $ics = substr($ics, 3); } - - $lines = explode("\n", preg_replace("/\r?\n[ \t]/", '', str_replace("\r\n", "\n", $ics))); - + $ics = preg_replace("/\r?\n[ \t]/", '', $ics); + if (! mb_check_encoding($ics, 'UTF-8') || str_contains($ics, "\0")) { + throw new ChannelSyncException('Kalender enthält ungültige Zeichen.'); + } + $lines = explode("\n", str_replace("\r\n", "\n", $ics)); + $stack = []; + $calendar = []; + $event = []; $periods = []; - $event = null; + $identities = []; + $started = false; + $closed = false; foreach ($lines as $line) { $line = rtrim($line, "\r"); - - if ($line === 'BEGIN:VEVENT') { - $event = []; - + if ($line === '' && $stack === []) { continue; } - - if ($line === 'END:VEVENT') { - if ($event !== null && ($period = $this->toPeriod($event))) { - $periods[] = $period; + if ($closed || ! preg_match('/^((?:[^:"]|"[^"]*")*):(.*)$/D', $line, $match)) { + throw new ChannelSyncException('Kalender ist unvollständig oder enthält ungültige Inhaltszeilen.'); + } + $parts = preg_split('/;(?=(?:[^"]*"[^"]*")*[^"]*$)/', $match[1]); + $name = strtoupper(array_shift($parts)); + $value = $match[2]; + if (! preg_match('/^[A-Z0-9-]+$/D', $name)) { + throw new ChannelSyncException('Ungültige Kalendereigenschaft.'); + } + if ($name === 'BEGIN') { + $component = strtoupper($value); + if ($stack === []) { + if ($started || $component !== 'VCALENDAR') { + throw new ChannelSyncException('Die Antwort ist kein vollständiger iCal-Kalender.'); + } + $started = true; + } elseif ($component === 'VCALENDAR' || ($component === 'VEVENT' && $stack !== ['VCALENDAR'])) { + throw new ChannelSyncException('Ungültig verschachtelte Kalenderkomponente.'); } - $event = null; + if ($stack === ['VCALENDAR'] && ! in_array($component, ['VEVENT', 'VTIMEZONE'], true)) { + throw new ChannelSyncException('Nicht unterstützte Kalenderkomponente im Belegungsfeed.'); + } + if ($component === 'VEVENT') { + $event = []; + } + $stack[] = $component; continue; } + if ($name === 'END') { + if ($stack === [] || end($stack) !== strtoupper($value)) { + throw new ChannelSyncException('Kalenderkomponente ist nicht vollständig geschlossen.'); + } + if (end($stack) === 'VEVENT') { + $uid = trim($event['UID']['value'] ?? ''); + if ($uid === '') { + throw new ChannelSyncException('Ein Kalenderereignis hat keine eindeutige UID.'); + } + $period = $this->toPeriod($event); + $identity = $period ? $period->startsOn->toDateString().'|'.$period->endsOn->toDateString() : 'not-occupying'; + if (isset($identities[$uid]) && $identities[$uid] !== $identity) { + throw new ChannelSyncException('Eine UID enthält widersprüchliche Ereignisse; bitte den Portalkalender prüfen.'); + } + if (! isset($identities[$uid]) && $period !== null) { + $periods[] = $period; + } + $identities[$uid] = $identity; + } + array_pop($stack); + if ($stack === []) { + $closed = true; + } - if ($event !== null && str_contains($line, ':')) { - [$nameWithParams, $value] = explode(':', $line, 2); - $parts = explode(';', $nameWithParams); - $event[strtoupper($parts[0])] = ['value' => $value, 'params' => array_slice($parts, 1)]; + continue; } + if ($stack === []) { + throw new ChannelSyncException('Inhalt außerhalb des Kalenders.'); + } + $property = ['value' => $value, 'params' => $parts]; + if ($stack === ['VCALENDAR']) { + if (isset($calendar[$name]) && in_array($name, ['VERSION', 'PRODID', 'METHOD'], true)) { + throw new ChannelSyncException('Doppelte Kalender-Kopfdaten.'); + } + $calendar[$name] = $property; + } elseif ($stack === ['VCALENDAR', 'VEVENT']) { + if (isset($event[$name]) && in_array($name, ['UID', 'DTSTART', 'DTEND', 'STATUS'], true)) { + throw new ChannelSyncException('Doppelte Identitäts- oder Datumsangaben im Kalenderereignis.'); + } + $event[$name] = $property; + } + } + if (! $closed || $stack !== [] || ($calendar['VERSION']['value'] ?? '') !== '2.0' || blank($calendar['PRODID']['value'] ?? null)) { + throw new ChannelSyncException('Kalender ist unvollständig; VERSION, PRODID und geschlossene Komponenten sind erforderlich.'); + } + if (isset($calendar['METHOD']) && strtoupper($calendar['METHOD']['value']) !== 'PUBLISH') { + throw new ChannelSyncException('Erwartet wird ein vollständiger Kalenderstand, keine einzelne Kalendernachricht.'); } return $periods; } - /** - * @param array}> $event - */ + /** @param array}> $event */ private function toPeriod(array $event): ?ExternalPeriod { - if (! isset($event['DTSTART']) || strtoupper($event['STATUS']['value'] ?? '') === 'CANCELLED') { + $stamp = $event['DTSTAMP']['value'] ?? ''; + try { + if (! preg_match('/^\d{8}T\d{6}Z$/D', $stamp) || CarbonImmutable::createFromFormat('!Ymd\THis\Z', $stamp, 'UTC')->format('Ymd\THis\Z') !== $stamp) { + throw new \RuntimeException; + } + } catch (Throwable) { + throw new ChannelSyncException('Ein Ereignis benötigt einen gültigen UTC-Zeitstempel (DTSTAMP).'); + } + foreach (['RRULE', 'RDATE', 'EXDATE', 'RECURRENCE-ID', 'DURATION'] as $unsupported) { + if (isset($event[$unsupported])) { + throw new ChannelSyncException('Serien oder Dauerangaben werden für diesen Belegungskalender nicht unterstützt.'); + } + } + if (strtoupper($event['STATUS']['value'] ?? '') === 'CANCELLED') { return null; } - + if (! isset($event['DTSTART'])) { + throw new ChannelSyncException('Einem Kalenderereignis fehlt die Anreise.'); + } $start = $this->toDate($event['DTSTART']); - $end = isset($event['DTEND']) ? $this->toDate($event['DTEND']) : $start?->addDay(); - - if ($start === null || $end === null || $end->lessThanOrEqualTo($start)) { + if (! isset($event['DTEND']) && ! preg_match('/^\d{8}$/D', $event['DTSTART']['value'])) { + throw new ChannelSyncException('Zeitgebundene Ereignisse benötigen eine ausdrückliche Abreise.'); + } + $end = isset($event['DTEND']) ? $this->toDate($event['DTEND']) : $start->addDay(); + if (isset($event['DTEND']) && preg_match('/^\d{8}$/D', $event['DTSTART']['value']) !== preg_match('/^\d{8}$/D', $event['DTEND']['value'])) { + throw new ChannelSyncException('An- und Abreise verwenden verschiedene Datumstypen.'); + } + if ($end->lessThanOrEqualTo($start)) { + throw new ChannelSyncException('Ein Kalenderereignis hat keinen positiven Übernachtungszeitraum.'); + } + if (strtoupper($event['TRANSP']['value'] ?? '') === 'TRANSPARENT') { return null; } + $summary = $event['SUMMARY']['value'] ?? null; - $uid = $event['UID']['value'] ?? sha1($start->toDateString().'|'.$end->toDateString()); - - return new ExternalPeriod($uid, $start, $end, $this->unescape($event['SUMMARY']['value'] ?? null)); + return new ExternalPeriod($event['UID']['value'], $start, $end, $summary === null ? null : str_replace(['\\n', '\\N', '\\,', '\\;', '\\\\'], ["\n", "\n", ',', ';', '\\'], $summary)); } - /** - * @param array{value: string, params: list} $property - */ - private function toDate(array $property): ?CarbonImmutable + /** @param array{value: string, params: list} $property */ + private function toDate(array $property): CarbonImmutable { $value = trim($property['value']); - - if (preg_match('/^\d{8}$/', $value)) { - return CarbonImmutable::createFromFormat('!Ymd', $value); + foreach ($property['params'] as $param) { + if (str_starts_with(strtoupper($param), 'VALUE=')) { + $type = strtoupper(trim(substr($param, 6), '"')); + if (! in_array($type, ['DATE', 'DATE-TIME'], true) || ($type === 'DATE') !== (preg_match('/^\d{8}$/D', $value) === 1)) { + throw new ChannelSyncException('Ungültiger Datumswerttyp.'); + } + } + if (str_starts_with(strtoupper($param), 'TZID=') && (preg_match('/^\d{8}$/D', $value) || str_ends_with($value, 'Z'))) { + throw new ChannelSyncException('Unzulässige Kombination von Datum und Zeitzone.'); + } } - - if (preg_match('/^(\d{8})T(\d{6})(Z?)$/', $value, $match)) { - $timezone = $match[3] === 'Z' ? 'UTC' : $this->timezone($property['params']); - - return CarbonImmutable::createFromFormat('YmdHis', $match[1].$match[2], $timezone) - ->setTimezone(config('app.timezone')) - ->startOfDay(); + try { + if (preg_match('/^\d{8}$/D', $value)) { + $date = CarbonImmutable::createFromFormat('!Ymd', $value); + if ($date->format('Ymd') === $value) { + return $date; + } + } elseif (preg_match('/^(\d{8})T(\d{6})(Z?)$/D', $value, $match)) { + $zone = $match[3] === 'Z' ? 'UTC' : $this->timezone($property['params']); + $date = CarbonImmutable::createFromFormat('!YmdHis', $match[1].$match[2], $zone); + if ($date->format('YmdHis') === $match[1].$match[2]) { + return $date->setTimezone(config('app.timezone'))->startOfDay(); + } + } + } catch (Throwable) { + throw new ChannelSyncException('Ungültiges Kalenderdatum oder unbekannte Zeitzone.'); } - - return null; + throw new ChannelSyncException('Ungültiges Kalenderdatum.'); } - /** - * @param list $params - */ + /** @param list $params */ private function timezone(array $params): string { foreach ($params as $param) { if (str_starts_with(strtoupper($param), 'TZID=')) { - $tz = trim(substr($param, 5), '"'); + $zone = trim(substr($param, 5), '"'); + if (! in_array($zone, timezone_identifiers_list(), true)) { + throw new ChannelSyncException('Unbekannte Kalenderzeitzone.'); + } - return in_array($tz, timezone_identifiers_list(), true) ? $tz : config('app.timezone'); + return $zone; } } return config('app.timezone'); } - - private function unescape(?string $text): ?string - { - return $text === null ? null : str_replace(['\\n', '\\N', '\\,', '\\;', '\\\\'], ["\n", "\n", ',', ';', '\\'], $text); - } } diff --git a/app/Enums/ChannelBookingModel.php b/app/Enums/ChannelBookingModel.php new file mode 100644 index 0000000..7ba5631 --- /dev/null +++ b/app/Enums/ChannelBookingModel.php @@ -0,0 +1,21 @@ + 'Vermittlung / Anfrage', + self::PortalBooking => 'Portalbuchung', + self::Mixed => 'Gemischt', + }; + } +} diff --git a/app/Enums/ChannelEchoBehavior.php b/app/Enums/ChannelEchoBehavior.php new file mode 100644 index 0000000..2782070 --- /dev/null +++ b/app/Enums/ChannelEchoBehavior.php @@ -0,0 +1,21 @@ + 'Noch ungeprüft', + self::NoReexport => 'Im geprüften Fall keine Weitergabe importierter Ereignisse', + self::Reexports => 'Gibt importierte Ereignisse weiter – neue Belegungen erst klären', + }; + } +} diff --git a/app/Enums/ChannelExportMode.php b/app/Enums/ChannelExportMode.php new file mode 100644 index 0000000..eafb8b8 --- /dev/null +++ b/app/Enums/ChannelExportMode.php @@ -0,0 +1,19 @@ + 'Testbetrieb: nur eigene Belegungen', + self::Regular => 'Regulär: alle übrigen Kanäle einbeziehen', + }; + } +} diff --git a/app/Enums/ChannelStatus.php b/app/Enums/ChannelStatus.php new file mode 100644 index 0000000..4ee8b99 --- /dev/null +++ b/app/Enums/ChannelStatus.php @@ -0,0 +1,21 @@ + 'Noch nicht eingerichtet', + self::Active => 'Aktiv', + self::Paused => 'Pausiert', + }; + } +} diff --git a/app/Filament/Resources/BlockedPeriods/BlockedPeriodResource.php b/app/Filament/Resources/BlockedPeriods/BlockedPeriodResource.php index 9456781..fba784b 100644 --- a/app/Filament/Resources/BlockedPeriods/BlockedPeriodResource.php +++ b/app/Filament/Resources/BlockedPeriods/BlockedPeriodResource.php @@ -2,17 +2,23 @@ namespace App\Filament\Resources\BlockedPeriods; +use App\Actions\ResolveChannelOccupation; use App\Filament\Concerns\FollowsAdminMode; use App\Filament\Resources\BlockedPeriods\Pages\ManageBlockedPeriods; use App\Models\BlockedPeriod; +use App\Models\Booking; +use App\Models\Channel; use App\Models\Property; use BackedEnum; +use Filament\Actions\Action; use Filament\Actions\DeleteAction; use Filament\Actions\EditAction; use Filament\Forms\Components\DatePicker; use Filament\Forms\Components\Select; use Filament\Forms\Components\TextInput; +use Filament\Notifications\Notification; use Filament\Resources\Resource; +use Filament\Schemas\Components\Utilities\Get; use Filament\Schemas\Schema; use Filament\Support\Icons\Heroicon; use Filament\Tables\Columns\TextColumn; @@ -83,14 +89,50 @@ public static function table(Table $table): Table default => $state, }) ->badge(), + TextColumn::make('channel.name')->label('Importkanal')->placeholder('Eigene Sperre'), + TextColumn::make('originChannel.name')->label('Ursprungskanal')->placeholder('Unbekannt')->toggleable(), + TextColumn::make('id')->label('Interne Sperr-ID')->toggleable(isToggledHiddenByDefault: true), + TextColumn::make('external_uid')->label('Externe UID')->limit(30)->toggleable(), + TextColumn::make('occupation_state')->label('Belegungsführung')->state(fn (BlockedPeriod $record): string => $record->is_representation + ? ($record->linked_booking_id ? 'Darstellung von Buchung #'.$record->linked_booking_id : 'Darstellung von Sperre #'.$record->canonical_block_id) + : ($record->export_approved ? 'Führende Belegung' : 'Intern gesperrt – Export erst klären'))->badge(), + TextColumn::make('needs_review')->label('Prüfung')->formatStateUsing(fn (bool $state): string => $state ? 'Bitte prüfen' : '–')->badge() + ->description(fn (BlockedPeriod $record): ?string => $record->review_note), ]) ->filters([ + Filter::make('needs_review')->label('Nur Prüffälle')->query(fn (Builder $query): Builder => $query->where('needs_review', true)), Filter::make('upcoming') ->label('Nur kommende') ->default() ->query(fn (Builder $query): Builder => $query->whereDate('ends_on', '>=', today())), ]) ->recordActions([ + Action::make('resolve')->label('Belegung zuordnen / klären') + ->visible(fn (BlockedPeriod $record): bool => in_array($record->source, ['channel', 'email'], true)) + ->authorize(fn (BlockedPeriod $record): bool => auth()->user()?->can('update', $record) ?? false) + ->modalDescription('Nur nach persönlicher Prüfung zuordnen. Eine Darstellung steuert keine eigene Belegung mehr; die führende Buchung oder Sperre übernimmt Änderungen und Stornierungen. Kalenderereignisse und UIDs bleiben nachvollziehbar erhalten.') + ->schema([ + Select::make('resolution')->label('Fachliche Klärung')->options(['independent' => 'Eigenständige Belegung bestätigen', 'block' => 'Weitere Darstellung einer vorhandenen Sperre', 'booking' => 'Weitere Darstellung einer vorhandenen Buchung'])->default('independent')->required()->live(), + Select::make('target_id')->label('Führende Belegung mit demselben Zeitraum') + ->visible(fn (Get $get): bool => $get('resolution') !== 'independent') + ->required(fn (Get $get): bool => $get('resolution') !== 'independent') + ->options(function (BlockedPeriod $record, Get $get): array { + if ($get('resolution') === 'booking') { + return Booking::query()->where('property_id', $record->property_id)->occupying()->whereDate('arrival', $record->starts_on)->whereDate('departure', $record->ends_on)->get() + ->mapWithKeys(fn (Booking $booking): array => [$booking->id => 'Buchung '.$booking->reference])->all(); + } + + return BlockedPeriod::query()->where('property_id', $record->property_id)->occupying()->whereKeyNot($record->id)->whereDate('starts_on', $record->starts_on)->whereDate('ends_on', $record->ends_on)->get() + ->mapWithKeys(fn (BlockedPeriod $block): array => [$block->id => '#'.$block->id.' · '.($block->reason ?? 'Sperre')])->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()) + ->default(fn (BlockedPeriod $record): ?int => $record->origin_channel_id)->placeholder('Unbekannt / eigene Vermietung'), + ]) + ->action(function (BlockedPeriod $record, array $data, ResolveChannelOccupation $resolve): void { + $resolve->handle($record, $data['resolution'], filled($data['target_id'] ?? null) ? (int) $data['target_id'] : null, filled($data['origin_channel_id'] ?? null) ? (int) $data['origin_channel_id'] : null); + Notification::make()->title('Belegungszuordnung gespeichert')->success()->send(); + }), EditAction::make()->visible(fn (BlockedPeriod $record): bool => $record->source === 'manual'), DeleteAction::make()->visible(fn (BlockedPeriod $record): bool => $record->source === 'manual'), ]); diff --git a/app/Filament/Resources/Properties/RelationManagers/ChannelsRelationManager.php b/app/Filament/Resources/Properties/RelationManagers/ChannelsRelationManager.php index 0abd3d0..b26ef0c 100644 --- a/app/Filament/Resources/Properties/RelationManagers/ChannelsRelationManager.php +++ b/app/Filament/Resources/Properties/RelationManagers/ChannelsRelationManager.php @@ -2,15 +2,24 @@ namespace App\Filament\Resources\Properties\RelationManagers; +use App\Actions\ConfigureChannel; +use App\Actions\RotateChannelToken; use App\Actions\SyncChannel; use App\Channels\ChannelRegistry; +use App\Channels\ICal\ICalFeed; +use App\Channels\ICal\ICalParser; +use App\Enums\ChannelBookingModel; +use App\Enums\ChannelEchoBehavior; +use App\Enums\ChannelExportMode; +use App\Enums\ChannelStatus; use App\Models\Channel; use App\Models\ChannelSyncLog; use Filament\Actions\Action; use Filament\Actions\CreateAction; -use Filament\Actions\DeleteAction; use Filament\Actions\EditAction; +use Filament\Forms\Components\DateTimePicker; use Filament\Forms\Components\Select; +use Filament\Forms\Components\Textarea; use Filament\Forms\Components\TextInput; use Filament\Forms\Components\Toggle; use Filament\Infolists\Components\RepeatableEntry; @@ -24,6 +33,7 @@ use Filament\Support\Icons\Heroicon; use Filament\Tables\Columns\TextColumn; use Filament\Tables\Table; +use Illuminate\Database\Eloquent\Builder; class ChannelsRelationManager extends RelationManager { @@ -47,6 +57,9 @@ public function form(Schema $schema): Schema ->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('Buchungsmodell')->options(ChannelBookingModel::class)->default(ChannelBookingModel::Mixed)->required() + ->helperText('Fachliche Einordnung; löst keine automatischen Buchungsentscheidungen aus.'), Select::make('connector') ->label('Anbindung') ->options($registry->options()) @@ -56,13 +69,23 @@ public function form(Schema $schema): Schema Group::make() ->columnSpanFull() ->schema(fn (Get $get): array => filled($get('connector')) ? $registry->connectors()[$get('connector')]::settingsSchema() : []), - TextEntry::make('export_url') - ->label('Unsere Kalender-Adresse für dieses Portal') - ->helperText('Diese Adresse im Portal unter „Kalender importieren“ eintragen. Sie enthält alle Belegungen außer denen dieses Portals.') - ->state(fn (?Channel $record): ?string => $record?->exportUrl()) - ->copyable() - ->visible(fn (?Channel $record): bool => $record !== null) + 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.') @@ -79,9 +102,6 @@ public function form(Schema $schema): Schema ->maxLength(2048) ->visible(fn (Get $get): bool => (bool) $get('requires_manual_blocking')) ->columnSpanFull(), - Toggle::make('is_active') - ->label('Aktiv') - ->default(true), ]); } @@ -89,15 +109,17 @@ public function table(Table $table): Table { return $table ->recordTitleAttribute('name') - ->description('Unser System ist führend: Belegungen der Portale werden alle 5 Minuten eingelesen, jedes Portal erhält einen eigenen Kalender mit allen übrigen Belegungen.') + ->description('Für jedes neue Portal wird automatisch ein eigener dauerhafter Exportlink erzeugt. Über „Vertraulicher Exportlink“ kopieren Sie ihn in das Portal. Die Importadresse erhalten Sie vom Portal. Import und Export sind getrennt schaltbar; eine Pause hält den letzten gültigen Exportstand.') + ->modifyQueryUsing(fn (Builder $query) => $query->withCount(['blockedPeriods as review_count' => fn ($blocks) => $blocks->where('needs_review', true)])) ->columns([ TextColumn::make('name')->label('Portal')->weight('medium'), - TextColumn::make('status') - ->label('Status') + TextColumn::make('status')->label('Kanalstatus')->badge(), + TextColumn::make('import_state') + ->label('Import') ->badge() ->state(fn (Channel $record): string => match (true) { - ! $record->is_active => 'Inaktiv', - ! $record->importsOccupations() => 'Nur Export', + ! $record->is_active || ! $record->import_enabled => 'Pausiert', + ! $record->importsOccupations() => 'Nicht eingerichtet', $record->last_error !== null => 'Fehler', $record->isStale() => 'Veraltet', default => 'OK', @@ -109,14 +131,46 @@ public function table(Table $table): Table }) ->tooltip(fn (Channel $record): ?string => $record->last_error), TextColumn::make('last_success_at')->label('Letzter Abgleich')->since()->placeholder('–'), + TextColumn::make('last_error_at')->label('Letzter Importfehler')->dateTime('d.m.Y H:i')->placeholder('–')->toggleable(), + TextColumn::make('last_import_events')->label('Ereignisse'), + TextColumn::make('export_state')->label('Export')->badge()->state(fn (Channel $record): string => $record->exportsOccupations() ? 'Aktuell' : ($record->export_snapshot_at ? 'Eingefroren' : 'Kein Stand (503)')), + TextColumn::make('export_mode')->label('Exportmodus'), + TextColumn::make('echo_behavior')->label('Rückkopplung')->toggleable(), + TextColumn::make('portal_verified_at')->label('Übernahme im Portal persönlich geprüft')->dateTime('d.m.Y H:i')->placeholder('Nicht bestätigt')->toggleable(), + TextColumn::make('review_count')->label('Prüffälle')->badge(), + TextColumn::make('warning_count')->label('Hinweise')->state(fn (Channel $record): int => count($record->sync_warnings ?? [])) + ->tooltip(fn (Channel $record): string => implode(' ', $record->sync_warnings ?? []))->badge(), + TextColumn::make('external_poll_minutes')->label('Erwarteter Portalabruf')->suffix(' Min.')->placeholder('Unbekannt')->toggleable(), + TextColumn::make('last_export_requested_at')->label('Letzter Feedabruf (Client unbekannt)')->dateTime('d.m.Y H:i')->placeholder('–')->toggleable(), TextColumn::make('requires_manual_blocking') ->label('Handpflege') ->formatStateUsing(fn (bool $state): string => $state ? 'ja' : '–'), ]) ->headerActions([ - CreateAction::make(), + CreateAction::make()->using(fn (array $data): Channel => app(ConfigureChannel::class)->handle($this->getOwnerRecord(), $data)) + ->modalDescription('Name und Anbindung wählen. Der eigene Exportlink entsteht automatisch beim Speichern. Die externe Importadresse kann auch später ergänzt werden. Für den normalen kanalübergreifenden Betrieb den regulären Exportmodus bewusst wählen.') + ->successNotificationTitle('Portal angelegt – eigener Exportlink automatisch erzeugt'), ]) ->recordActions([ + Action::make('coverage')->label('Exportumfang prüfen')->modalSubmitAction(false)->modalCancelActionLabel('Schließen') + ->modalDescription('Aktuell berechneter Umfang der nächsten aktiven Ausgabe. Bei pausiertem Export bleibt der gespeicherte Stand maßgeblich. Ausgelassene Ereignisse sind unter Sperrzeiten mit Herkunft und Zuordnung einsehbar.') + ->schema([ + TextEntry::make('export_events')->label('Ereignisse im berechneten Feed')->state(fn (Channel $record): int => count(app(ICalParser::class)->parse(app(ICalFeed::class)->build($record)))), + TextEntry::make('held_events')->label('Importe in persönlicher Klärung oder zugeordnete Darstellungen')->state(fn (Channel $record): int => $record->property->blockedPeriods()->where(fn ($query) => $query->where('export_approved', false)->orWhere('is_representation', true))->count()), + ]), + Action::make('exportLink')->label('Vertraulicher Exportlink') + ->modalDescription('Diese Adresse erlaubt den Kalenderabruf. Nur dem vorgesehenen Portal geben. Ein Abruf beweist keine tatsächliche Übernahme.') + ->schema([ + TextEntry::make('export_url')->label('Kalenderadresse')->state(fn (Channel $record): string => $record->exportUrl())->copyable(), + TextEntry::make('token_transition')->label('Bisheriger Link bleibt gültig bis')->state(fn (Channel $record): string => $record->previous_export_token_expires_at?->format('d.m.Y H:i') ?? 'Keine Übergangsphase'), + ])->modalSubmitAction(false)->modalCancelActionLabel('Schließen'), + Action::make('rotateToken')->label('Exporttoken wechseln')->requiresConfirmation() + ->modalDescription('Eine neue Adresse entsteht. Die bisherige bleibt während der Übergangsphase gültig. Die neue Adresse selbst im Portal eintragen; danach Ablauf beachten.') + ->schema([TextInput::make('grace_hours')->label('Übergangsphase in Stunden')->integer()->minValue(24)->maxValue(720)->default(168)->required()]) + ->action(function (Channel $record, array $data, RotateChannelToken $rotate): void { + $rotate->handle($record, (int) $data['grace_hours']); + Notification::make()->title('Token gewechselt – neuen Exportlink im Portal eintragen')->success()->send(); + }), Action::make('sync') ->label('Jetzt abgleichen') ->icon(Heroicon::OutlinedArrowPath) @@ -141,20 +195,23 @@ public function table(Table $table): Table 'time' => $log->created_at->format('d.m. H:i'), 'result' => $log->successful ? "✓ {$log->events} Belegungen (+{$log->added} ~{$log->changed} -{$log->removed})" : '✗ '.$log->message, 'conflicts' => $log->conflicts ?: '', + 'warnings' => implode(' ', $log->warnings ?? []), ])->all()) ->table([ TableColumn::make('Zeit'), TableColumn::make('Ergebnis'), TableColumn::make('Konflikte'), + TableColumn::make('Hinweise'), ]) ->schema([ TextEntry::make('time'), TextEntry::make('result'), TextEntry::make('conflicts'), + TextEntry::make('warnings'), ]), ]), - EditAction::make(), - DeleteAction::make(), + EditAction::make()->mutateRecordDataUsing(fn (array $data, Channel $record): array => [...$data, 'settings' => $record->settings]) + ->using(fn (Channel $record, array $data): Channel => app(ConfigureChannel::class)->handle($this->getOwnerRecord(), $data, $record)), ]); } } diff --git a/app/Filament/Widgets/BookingStats.php b/app/Filament/Widgets/BookingStats.php index b5f58a8..a54978d 100644 --- a/app/Filament/Widgets/BookingStats.php +++ b/app/Filament/Widgets/BookingStats.php @@ -66,7 +66,7 @@ private function occupancy(CarbonImmutable $from, CarbonImmutable $until): int $nights = []; $periods = Booking::query()->whereIn('status', BookingStatus::occupying())->overlapping($from, $until)->get(['arrival', 'departure']) ->map(fn (Booking $booking): array => [$booking->arrival, $booking->departure]) - ->concat(BlockedPeriod::query()->whereNotNull('channel_id')->overlapping($from, $until)->get(['starts_on', 'ends_on']) + ->concat(BlockedPeriod::query()->occupying()->whereNotNull('channel_id')->overlapping($from, $until)->get(['starts_on', 'ends_on']) ->map(fn (BlockedPeriod $block): array => [$block->starts_on, $block->ends_on])); foreach ($periods as [$start, $end]) { diff --git a/app/Http/Controllers/ChannelController.php b/app/Http/Controllers/ChannelController.php index 5632b24..3a2a6ba 100644 --- a/app/Http/Controllers/ChannelController.php +++ b/app/Http/Controllers/ChannelController.php @@ -4,7 +4,7 @@ use App\Actions\MonitorChannels; use App\Actions\ProcessPortalMail; -use App\Channels\ICal\ICalFeed; +use App\Channels\ICal\ICalExport; use App\Channels\Mail\MailboxReader; use App\Channels\Mail\PortalMail; use App\Enums\ChannelTaskStatus; @@ -23,16 +23,23 @@ */ class ChannelController extends Controller { - public function feed(string $token, ICalFeed $feed): Response + public function feed(string $token, ICalExport $feed): Response { - $channel = Channel::query()->where('export_token', $token)->where('is_active', true)->firstOrFail(); + $channel = Channel::query()->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); - return response($feed->build($channel), 200, [ + $body = $feed->build($channel); + if ($body === null) { + return response('Der Export ist pausiert; es liegt noch kein gültiger Kalenderstand vor.', 503, ['Retry-After' => '300', 'Cache-Control' => 'no-store']); + } + + return response($body, 200, [ 'Content-Type' => 'text/calendar; charset=utf-8', 'Content-Disposition' => 'inline; filename="belegung.ics"', 'Cache-Control' => 'no-cache, max-age=0', + 'X-Fewo-Export-State' => $channel->exportsOccupations() ? 'live' : 'frozen', ]); } diff --git a/app/Models/BlockedPeriod.php b/app/Models/BlockedPeriod.php index 54d7638..8ff168d 100644 --- a/app/Models/BlockedPeriod.php +++ b/app/Models/BlockedPeriod.php @@ -3,6 +3,7 @@ namespace App\Models; use App\Models\Concerns\BelongsToTenant; +use App\Models\Concerns\HasChannelProvenance; use App\Observers\BlockedPeriodObserver; use Carbon\CarbonInterface; use Database\Factories\BlockedPeriodFactory; @@ -13,17 +14,20 @@ use Illuminate\Database\Eloquent\Factories\HasFactory; use Illuminate\Database\Eloquent\Model; use Illuminate\Database\Eloquent\Relations\BelongsTo; +use Illuminate\Database\Eloquent\SoftDeletes; /** * Dates that are not bookable (own use, maintenance, bookings from portals). * Like bookings, ends_on is the first free day again. */ #[ObservedBy(BlockedPeriodObserver::class)] -#[Fillable(['property_id', 'channel_id', 'starts_on', 'ends_on', 'reason', 'source', 'external_uid'])] +#[Fillable(['property_id', 'channel_id', 'origin_channel_id', 'starts_on', 'ends_on', 'reason', 'source', 'external_uid', 'needs_review', 'review_note', 'missing_imports', 'is_representation', 'canonical_block_id', 'linked_booking_id', 'export_approved', 'reviewed_at'])] class BlockedPeriod extends Model { /** @use HasFactory */ - use BelongsToTenant, HasFactory; + use BelongsToTenant, HasChannelProvenance, HasFactory, SoftDeletes; + + protected $attributes = ['is_representation' => false, 'export_approved' => true]; /** * Get the attributes that should be cast. @@ -35,6 +39,11 @@ protected function casts(): array return [ 'starts_on' => 'immutable_date', 'ends_on' => 'immutable_date', + 'needs_review' => 'boolean', + 'missing_imports' => 'integer', + 'is_representation' => 'boolean', + 'export_approved' => 'boolean', + 'reviewed_at' => 'immutable_datetime', ]; } @@ -54,6 +63,33 @@ public function channel(): BelongsTo return $this->belongsTo(Channel::class); } + /** @return BelongsTo */ + public function originChannel(): BelongsTo + { + return $this->belongsTo(Channel::class); + } + + /** @return BelongsTo */ + public function canonicalBlock(): BelongsTo + { + return $this->belongsTo(self::class, 'canonical_block_id')->withTrashed(); + } + + /** @return BelongsTo */ + public function linkedBooking(): BelongsTo + { + return $this->belongsTo(Booking::class, 'linked_booking_id'); + } + + /** @param Builder $query + * @return Builder + */ + #[Scope] + protected function occupying(Builder $query): Builder + { + return $query->where('is_representation', false); + } + /** * @param Builder $query * @return Builder diff --git a/app/Models/Booking.php b/app/Models/Booking.php index 8b6934d..80c3dec 100644 --- a/app/Models/Booking.php +++ b/app/Models/Booking.php @@ -5,6 +5,7 @@ use App\Enums\BookingStatus; use App\Enums\ReferralSource; use App\Models\Concerns\BelongsToTenant; +use App\Models\Concerns\HasChannelProvenance; use App\Observers\BookingObserver; use Carbon\CarbonInterface; use Database\Factories\BookingFactory; @@ -28,6 +29,8 @@ 'guest_id', 'status', 'source', + 'import_channel_id', + 'origin_channel_id', 'referral_source', 'utm_source', 'utm_medium', @@ -66,7 +69,14 @@ class Booking extends Model { /** @use HasFactory */ - use BelongsToTenant, HasFactory; + use BelongsToTenant, HasChannelProvenance, HasFactory; + + public const DIRECT_SOURCES = ['website', 'manual', 'phone', 'direct', 'email']; + + public function isDirect(): bool + { + return $this->import_channel_id === null && $this->origin_channel_id === null && in_array($this->source, self::DIRECT_SOURCES, true); + } protected static function booted(): void { diff --git a/app/Models/Channel.php b/app/Models/Channel.php index 00884dd..c063e6b 100644 --- a/app/Models/Channel.php +++ b/app/Models/Channel.php @@ -4,6 +4,10 @@ use App\Channels\ChannelRegistry; use App\Channels\Contracts\ChannelConnector; +use App\Enums\ChannelBookingModel; +use App\Enums\ChannelEchoBehavior; +use App\Enums\ChannelExportMode; +use App\Enums\ChannelStatus; use App\Enums\TenantServiceKey; use App\Models\Concerns\BelongsToTenant; use App\Tenancy\TenantFeatures; @@ -22,18 +26,31 @@ * 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. */ -#[Fillable(['property_id', 'name', 'connector', 'settings', 'is_active', 'requires_manual_blocking', 'manage_url'])] -#[Hidden(['export_token'])] +#[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'])] +#[Hidden(['export_token', 'previous_export_token', 'export_snapshot', 'settings'])] class Channel extends Model { /** @use HasFactory */ use BelongsToTenant, HasFactory; + protected $attributes = [ + 'status' => 'setup', 'booking_model' => 'mixed', 'import_enabled' => false, + 'export_enabled' => false, 'export_mode' => 'test', + 'echo_behavior' => 'unverified', + ]; + protected static function booted(): void { static::creating(function (Channel $channel): void { $channel->export_token ??= Str::random(48); }); + static::saving(function (Channel $channel): void { + if ($channel->isDirty('status')) { + $channel->is_active = $channel->status === ChannelStatus::Active; + } elseif ($channel->isDirty('is_active')) { + $channel->status = $channel->is_active ? ChannelStatus::Active : ChannelStatus::Paused; + } + }); } /** @@ -45,6 +62,18 @@ protected function casts(): array { return [ 'settings' => 'array', + 'status' => ChannelStatus::class, + 'booking_model' => ChannelBookingModel::class, + 'echo_behavior' => ChannelEchoBehavior::class, + 'portal_verified_at' => 'immutable_datetime', + 'export_mode' => ChannelExportMode::class, + 'import_enabled' => 'boolean', + 'export_enabled' => 'boolean', + 'sync_warnings' => 'array', + 'last_error_at' => 'immutable_datetime', + 'export_snapshot_at' => 'immutable_datetime', + 'last_export_requested_at' => 'immutable_datetime', + 'previous_export_token_expires_at' => 'immutable_datetime', 'is_active' => 'boolean', 'requires_manual_blocking' => 'boolean', 'last_synced_at' => 'immutable_datetime', @@ -92,7 +121,7 @@ public function tasks(): HasMany #[Scope] protected function active(Builder $query): Builder { - return $query->where('is_active', true); + return $query->where('is_active', true)->where('status', ChannelStatus::Active); } public function connector(): ChannelConnector @@ -102,7 +131,13 @@ public function connector(): ChannelConnector public function importsOccupations(): bool { - return $this->is_active && $this->servesItsLandlord() && $this->connector()->canImport($this); + return $this->is_active && $this->status === ChannelStatus::Active && $this->import_enabled + && $this->servesItsLandlord() && $this->connector()->canImport($this); + } + + public function exportsOccupations(): bool + { + return $this->is_active && $this->status === ChannelStatus::Active && $this->export_enabled && $this->servesItsLandlord(); } /** diff --git a/app/Models/ChannelSyncLog.php b/app/Models/ChannelSyncLog.php index 785f9bb..3fa2e1d 100644 --- a/app/Models/ChannelSyncLog.php +++ b/app/Models/ChannelSyncLog.php @@ -7,7 +7,7 @@ use Illuminate\Database\Eloquent\Model; use Illuminate\Database\Eloquent\Relations\BelongsTo; -#[Fillable(['channel_id', 'successful', 'events', 'added', 'changed', 'removed', 'conflicts', 'message', 'duration_ms'])] +#[Fillable(['channel_id', 'successful', 'events', 'added', 'changed', 'removed', 'conflicts', 'message', 'duration_ms', 'warnings'])] class ChannelSyncLog extends Model { use BelongsToTenant; @@ -23,6 +23,7 @@ protected function casts(): array { return [ 'successful' => 'boolean', + 'warnings' => 'array', 'created_at' => 'immutable_datetime', ]; } diff --git a/app/Models/ChannelTask.php b/app/Models/ChannelTask.php index e73e6d8..abcb0a3 100644 --- a/app/Models/ChannelTask.php +++ b/app/Models/ChannelTask.php @@ -2,6 +2,7 @@ namespace App\Models; +use App\Availability\AvailabilityChecker; use App\Enums\ChannelTaskAction; use App\Enums\ChannelTaskStatus; use App\Models\Concerns\BelongsToTenant; @@ -61,6 +62,14 @@ protected function open(Builder $query): Builder public function complete(string $completedBy): void { + if ($this->status !== ChannelTaskStatus::Open) { + return; + } + if ($this->action === ChannelTaskAction::Unblock && ! app(AvailabilityChecker::class)->isAvailable($this->channel->property, $this->starts_on, $this->ends_on)) { + $this->update(['status' => ChannelTaskStatus::Dismissed, 'automation_error' => 'Aktuell belegt – Entsperraufgabe nicht mehr gültig.']); + + return; + } $this->update([ 'status' => ChannelTaskStatus::Done, 'completed_by' => $completedBy, diff --git a/app/Models/Concerns/HasChannelProvenance.php b/app/Models/Concerns/HasChannelProvenance.php new file mode 100644 index 0000000..d95499c --- /dev/null +++ b/app/Models/Concerns/HasChannelProvenance.php @@ -0,0 +1,22 @@ +getAttribute($field); + if ($id !== null && ! Channel::withoutGlobalScope('tenant')->whereKey($id)->where('property_id', $model->property_id)->exists()) { + throw ValidationException::withMessages([$field => 'Der Kanal muss zur selben Wohnung gehören.']); + } + } + }); + } +} diff --git a/app/Observers/BlockedPeriodObserver.php b/app/Observers/BlockedPeriodObserver.php index c937b0c..9daf61e 100644 --- a/app/Observers/BlockedPeriodObserver.php +++ b/app/Observers/BlockedPeriodObserver.php @@ -5,41 +5,63 @@ use App\Actions\CreateChannelTasks; use App\Enums\ChannelTaskAction; use App\Models\BlockedPeriod; +use App\Models\Property; +use App\Tenancy\TenantContext; use Carbon\CarbonImmutable; -use Illuminate\Contracts\Events\ShouldHandleEventsAfterCommit; +use Illuminate\Support\Facades\DB; /** * Manual blocks and occupations imported from one portal must also reach the manually maintained * portals – except the portal they came from. */ -class BlockedPeriodObserver implements ShouldHandleEventsAfterCommit +class BlockedPeriodObserver { public function __construct(private CreateChannelTasks $createChannelTasks) {} public function created(BlockedPeriod $block): void { - $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Block); + if (! $block->is_representation && $block->export_approved) { + $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Block); + } + } + + public function restored(BlockedPeriod $block): void + { + $this->created($block); } public function updated(BlockedPeriod $block): void { - if (! $block->wasChanged(['starts_on', 'ends_on'])) { + if (! $block->wasChanged(['starts_on', 'ends_on', 'is_representation', 'export_approved'])) { return; } - $this->tasks($block, CarbonImmutable::parse($block->getOriginal('starts_on')), CarbonImmutable::parse($block->getOriginal('ends_on')), ChannelTaskAction::Unblock); - $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Block); + $this->tasks($block, CarbonImmutable::parse($block->getRawOriginal('starts_on')), CarbonImmutable::parse($block->getRawOriginal('ends_on')), ChannelTaskAction::Unblock); + if (! $block->is_representation && $block->export_approved && ! $block->trashed()) { + $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Block); + } } public function deleted(BlockedPeriod $block): void { - $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Unblock); + if (! $block->is_representation) { + $this->tasks($block, $block->starts_on, $block->ends_on, ChannelTaskAction::Unblock); + } } private function tasks(BlockedPeriod $block, CarbonImmutable $startsOn, CarbonImmutable $endsOn, ChannelTaskAction $action): void { $reason = $block->channel ? "Belegung über {$block->channel->name}" : 'Sperrzeit'.($block->reason ? ": {$block->reason}" : ''); - $this->createChannelTasks->handle($block->property, $startsOn, $endsOn, $action, $reason, $block->channel_id); + $propertyId = $block->property_id; + $channelId = $block->channel_id; + $originId = $block->origin_channel_id; + $external = $channelId !== null || $originId !== null || $block->source !== 'manual'; + DB::afterCommit(function () use ($propertyId, $channelId, $originId, $external, $startsOn, $endsOn, $action, $reason): void { + $property = Property::withoutGlobalScope('tenant')->find($propertyId); + if ($property !== null) { + app(TenantContext::class)->run($property->tenant, fn () => $this->createChannelTasks->handle($property, $startsOn, $endsOn, $action, $reason, $channelId, $originId, $external)); + } + }); } } diff --git a/app/Observers/BookingObserver.php b/app/Observers/BookingObserver.php index d71996a..ddb942e 100644 --- a/app/Observers/BookingObserver.php +++ b/app/Observers/BookingObserver.php @@ -6,12 +6,15 @@ use App\Enums\BookingStatus; use App\Enums\ChannelTaskAction; use App\Models\Booking; -use Illuminate\Contracts\Events\ShouldHandleEventsAfterCommit; +use App\Models\Property; +use App\Tenancy\TenantContext; +use Carbon\CarbonImmutable; +use Illuminate\Support\Facades\DB; /** * Keeps manually maintained portals in step when a booking starts or stops occupying the calendar. */ -class BookingObserver implements ShouldHandleEventsAfterCommit +class BookingObserver { public function __construct(private CreateChannelTasks $createChannelTasks) {} @@ -24,17 +27,18 @@ public function created(Booking $booking): void public function updated(Booking $booking): void { - if (! $booking->wasChanged('status')) { + if (! $booking->wasChanged(['status', 'arrival', 'departure'])) { return; } - $before = $this->occupies($booking->getOriginal('status')); + $before = $this->occupies($booking->getRawOriginal('status')); $after = $this->occupies($booking->status); - if (! $before && $after) { + if ($before && (! $after || $booking->wasChanged(['arrival', 'departure']))) { + $this->tasks($booking, ChannelTaskAction::Unblock, CarbonImmutable::parse($booking->getRawOriginal('arrival')), CarbonImmutable::parse($booking->getRawOriginal('departure'))); + } + if ($after && (! $before || $booking->wasChanged(['arrival', 'departure']))) { $this->tasks($booking, ChannelTaskAction::Block); - } elseif ($before && ! $after) { - $this->tasks($booking, ChannelTaskAction::Unblock); } } @@ -45,14 +49,20 @@ private function occupies(BookingStatus|string|null $status): bool return in_array($status, BookingStatus::occupying(), true); } - private function tasks(Booking $booking, ChannelTaskAction $action): void + private function tasks(Booking $booking, ChannelTaskAction $action, ?CarbonImmutable $startsOn = null, ?CarbonImmutable $endsOn = null): void { - $property = $booking->property()->withoutGlobalScope('tenant')->first(); - - if ($property === null) { - return; - } - - $this->createChannelTasks->handle($property, $booking->arrival, $booking->departure, $action, "Buchung {$booking->reference}"); + $propertyId = $booking->property_id; + $channelId = $booking->import_channel_id; + $originId = $booking->origin_channel_id; + $external = ! $booking->isDirect(); + $startsOn ??= $booking->arrival; + $endsOn ??= $booking->departure; + $reason = "Buchung {$booking->reference}"; + DB::afterCommit(function () use ($propertyId, $channelId, $originId, $external, $startsOn, $endsOn, $action, $reason): void { + $property = Property::withoutGlobalScope('tenant')->find($propertyId); + if ($property !== null) { + app(TenantContext::class)->run($property->tenant, fn () => $this->createChannelTasks->handle($property, $startsOn, $endsOn, $action, $reason, $channelId, $originId, $external)); + } + }); } } diff --git a/config/channels.php b/config/channels.php index 3d0937e..b0183fb 100644 --- a/config/channels.php +++ b/config/channels.php @@ -25,4 +25,7 @@ */ 'uid_suffix' => '@fewo-stommer', + 'removal_confirmation_runs' => 2, + 'max_automatic_removals' => 5, + ]; diff --git a/database/factories/ChannelFactory.php b/database/factories/ChannelFactory.php index a46827f..b104935 100644 --- a/database/factories/ChannelFactory.php +++ b/database/factories/ChannelFactory.php @@ -24,6 +24,10 @@ public function definition(): array 'connector' => 'ical', 'settings' => ['import_url' => 'https://portal.example/ical/'.fake()->uuid().'.ics'], 'is_active' => true, + 'status' => 'active', + 'import_enabled' => true, + 'export_enabled' => true, + 'export_mode' => 'regular', 'requires_manual_blocking' => false, ]; } diff --git a/database/migrations/2026_10_27_154125_add_generic_ical_controls_and_provenance.php b/database/migrations/2026_10_27_154125_add_generic_ical_controls_and_provenance.php new file mode 100644 index 0000000..35a0e43 --- /dev/null +++ b/database/migrations/2026_10_27_154125_add_generic_ical_controls_and_provenance.php @@ -0,0 +1,76 @@ +string('status')->default('setup'); + $table->string('booking_model')->default('mixed'); + $table->boolean('import_enabled')->default(false); + $table->boolean('export_enabled')->default(false); + $table->string('export_mode')->default('test'); + $table->unsignedInteger('external_poll_minutes')->nullable(); + $table->dateTime('last_error_at')->nullable(); + $table->unsignedInteger('last_import_events')->default(0); + $table->json('sync_warnings')->nullable(); + $table->longText('export_snapshot')->nullable(); + $table->dateTime('export_snapshot_at')->nullable(); + $table->dateTime('last_export_requested_at')->nullable(); + $table->string('previous_export_token', 64)->nullable()->unique(); + $table->dateTime('previous_export_token_expires_at')->nullable(); + }); + Schema::table('blocked_periods', function (Blueprint $table) { + $table->foreignId('origin_channel_id')->nullable()->constrained('channels')->restrictOnDelete(); + $table->boolean('needs_review')->default(false); + $table->text('review_note')->nullable(); + $table->unsignedInteger('missing_imports')->default(0); + }); + Schema::table('bookings', function (Blueprint $table) { + $table->foreignId('import_channel_id')->nullable()->constrained('channels')->restrictOnDelete(); + $table->foreignId('origin_channel_id')->nullable()->constrained('channels')->restrictOnDelete(); + }); + Schema::table('channel_sync_logs', fn (Blueprint $table) => $table->json('warnings')->nullable()); + + /** Preserve existing directions and export scope without changing any occupancy. */ + DB::table('channels')->orderBy('id')->each(function (object $channel): void { + $settings = json_decode($channel->settings ?? '{}', true) ?: []; + DB::table('channels')->where('id', $channel->id)->update([ + 'status' => $channel->is_active ? 'active' : 'paused', + 'import_enabled' => $channel->is_active && filled($settings['import_url'] ?? null), + 'export_enabled' => (bool) $channel->is_active, + 'export_mode' => 'regular', + ]); + }); + } + + /** + * Reverse the migrations. + */ + public function down(): void + { + Schema::table('bookings', function (Blueprint $table) { + $table->dropConstrainedForeignId('origin_channel_id'); + $table->dropConstrainedForeignId('import_channel_id'); + }); + Schema::table('blocked_periods', function (Blueprint $table) { + $table->dropConstrainedForeignId('origin_channel_id'); + $table->dropColumn(['needs_review', 'review_note', 'missing_imports']); + }); + Schema::table('channel_sync_logs', fn (Blueprint $table) => $table->dropColumn('warnings')); + Schema::table('channels', fn (Blueprint $table) => $table->dropUnique(['previous_export_token'])); + Schema::table('channels', fn (Blueprint $table) => $table->dropColumn([ + 'status', 'booking_model', 'import_enabled', 'export_enabled', 'export_mode', 'external_poll_minutes', + 'last_error_at', 'last_import_events', 'sync_warnings', 'export_snapshot', 'export_snapshot_at', + 'last_export_requested_at', 'previous_export_token', 'previous_export_token_expires_at', + ])); + } +}; diff --git a/database/migrations/2026_10_27_170252_add_channel_occupation_resolution.php b/database/migrations/2026_10_27_170252_add_channel_occupation_resolution.php new file mode 100644 index 0000000..53fef3a --- /dev/null +++ b/database/migrations/2026_10_27_170252_add_channel_occupation_resolution.php @@ -0,0 +1,43 @@ +string('echo_behavior')->default('unverified'); + $table->text('echo_notes')->nullable(); + $table->text('operating_notes')->nullable(); + $table->dateTime('portal_verified_at')->nullable(); + }); + Schema::table('blocked_periods', function (Blueprint $table): void { + $table->softDeletes(); + $table->boolean('is_representation')->default(false); + $table->foreignId('canonical_block_id')->nullable()->constrained('blocked_periods')->nullOnDelete(); + $table->foreignId('linked_booking_id')->nullable()->constrained('bookings')->nullOnDelete(); + $table->boolean('export_approved')->default(true); + $table->dateTime('reviewed_at')->nullable(); + }); + } + + /** + * Reverse the migrations. + */ + public function down(): void + { + Schema::table('blocked_periods', function (Blueprint $table): void { + $table->dropConstrainedForeignId('canonical_block_id'); + $table->dropConstrainedForeignId('linked_booking_id'); + $table->dropColumn(['is_representation', 'export_approved', 'reviewed_at']); + $table->dropSoftDeletes(); + }); + Schema::table('channels', fn (Blueprint $table) => $table->dropColumn(['echo_behavior', 'echo_notes', 'operating_notes', 'portal_verified_at'])); + } +}; diff --git a/docs/PORTALE.md b/docs/PORTALE.md index 7686431..61a7c46 100644 --- a/docs/PORTALE.md +++ b/docs/PORTALE.md @@ -1,7 +1,11 @@ # Portal-Analyse: Kalender-Abgleich, Buchungshoheit, Empfehlung +**MVP-Folgeauftrag 27.10.2026:** [Bereitstellung und Benutzung](architecture/ical-mvp-inbetriebnahme-2026-10-27.md) beschreibt die automatische Generierung eines eigenen Exportlinks je Portal in der vorhandenen Oberfläche, persönliche Zuordnung mehrfacher Kalenderdarstellungen und konfigurierbares Echoverhalten. Die offene Frage zur zusätzlichen Kalenderpflege-Bestätigung bei Ostseeklar wird dort festgehalten. Reale Importadressen werden vom externen Portal bezogen und in der Oberfläche eingetragen. + Stand: 22.10.2026 · Grundlage: öffentliche Hilfeseiten und Vertragsunterlagen der Anbieter (Quellen unten). Konditionen, die nur Dritte nennen oder die vertragsabhängig sind, sind als **„prüfen“** markiert. +**Implementierungsergänzung 27.10.2026, noch nicht ausgeliefert:** [Generische iCal-Kanalkonfiguration](architecture/ical-kanalkonfiguration.md) dokumentiert die lokale Erweiterung mit unabhängigen Richtungen, Test-/Regulärmodus, eingefrorenen Exporten, Herkunft, sicherer Änderung/Entfernung und Tests. Die folgenden Anbieterangaben bleiben Recherche vom 22.10., keine neue Verifikation. Die frühere Beschreibung einer Mail/iCal-Übernahme anhand gleicher Termine in Abschnitt 4b ist im neuen Stand ersetzt: Zusammenführung nur über gemeinsame Referenz/UID; unbekannte Zuordnungen bleiben Prüffälle. Im Testmodus werden Fremdbelegungen auch nicht an andere Portale weitergegeben. Die von Lars berichtete erfolgreiche FeWo-direkt-Probe ist dort als einzelner Nutzerbericht getrennt von automatisierten Nachweisen erfasst. + ## 1. Kurzfazit 1. **Die meisten genannten Portale nehmen Kalender per iCal an** – FeWo-direkt, Ostseeklar und ferienundwohnen.de (automatisch nur im Premium-Inserat). Echtes „wir müssen führend sein“ verlangen vor allem **Systeme mit Online-Buchung über eine Software-Schnittstelle**: das Buchungssystem der Tourist-Information (DS Destination Solutions) und jedes Portal, sobald es per Channel-Manager-API angebunden ist (dann schaltet z. B. FeWo-direkt den iCal-Import ab). diff --git a/docs/STATUS.md b/docs/STATUS.md index 6aff001..0661a65 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -4,6 +4,14 @@ # Projektstand > Dieses Dokument ist der Einstieg für jede neue Arbeitssitzung. Bitte bei größeren Änderungen fortschreiben (Abschnitte „Fertig“, „Offen“, „Nächste Schritte“). +**iCal-MVP zur Auslieferung vorbereitet (27.10.2026):** Automatischer eigener dauerhafter Exportlink je frei benanntem Portalkanal in der Verwaltung; manuelle Klärung und Zuordnung mehrfach dargestellter Belegungen; führende Sperre/Buchung steuert Verfügbarkeit und Export, zugeordnete UID-Darstellungen bleiben nachvollziehbar. Archivierung erhält die Identität verschwundener und wiederkehrender Ereignisse. Konfigurierbares Echoverhalten, Exportumfang, Portal-Pflegehinweise und getrennte persönliche Übernahmeprüfung ergänzt. **359 Feature-Tests / 1701 Assertions lokal erfolgreich, Pint erfolgreich.** Der Nutzer hat Deployment und Migration auf der bestehenden Instanz ausdrücklich beauftragt. Keine separate Testinstallation. Vorab auf stommer.info gelesen: ein reiner FeWo-direkt-Exportkanal, keine Sperren und keine belegende Buchung; Link unverändert HTTP 200 ohne Ereignisse. Externe Importadressen fehlen dort noch und sollen auf Wunsch über die Oberfläche statt lokaler JSON-Datei eingetragen werden. [Benutzung, Zuordnung und praktische Abnahme](architecture/ical-mvp-inbetriebnahme-2026-10-27.md). Auslieferungsnachweis folgt nach Abschluss der bestehenden Pipeline. + +**Generische iCal-Kanäle lokal umgesetzt (27.10.2026):** Auf `feature/ical-portalkanaele` wurde das vorhandene Connector-System erweitert: getrennte Import-/Exportrichtungen, Einrichtungsstatus und Buchungsmodell, Test-/Regulärmodus, eingefrorener letzter Export bei Pause, kontrollierte Tokenrotation, zusätzliche Herkunft, strikte vollständige Feedprüfung, bestätigte Entfernung fehlender Ereignisse und Prüffälle statt datumsbasierter Mail/iCal-Zusammenführung. Portal-Aufgaben erhalten alte/neue Termine nach Commit und geben nur aktuell freie Nächte frei; überholte Automationsaufgaben werden vor Übergabe verworfen. **Abnahme lokal: 347 Feature-Tests / 1626 Assertions grün, darunter 44 neue iCal-Fälle; Pint erfolgreich.** Neue Migration ausschließlich an synthetischer SQLite-In-Memory-Testdatenbank geprüft, keine Anwendungsdatenbank migriert. [GAP-Analyse, Konfiguration, Grenzen, Testplan und Freigabe](architecture/ical-kanalkonfiguration.md). **Nicht ausgeliefert, keine echte Kalenderverknüpfung, kein Server-/Portalbestand verändert.** Bestehende Kanäle behalten bei späterer Migration ihren bisherigen regulären Exportumfang; neue starten ausgeschaltet im Testmodus. Offen vor Auslieferung: MariaDB-/Zielsystemprüfung, Bestandsklärung und ausdrückliche Freigabe realer Verbindungen. Die von Lars berichtete FeWo-direkt-Probe ist ein konkreter Nutzerbericht, kein allgemeiner Nachweis des Portalverhaltens. Der historische iCal-Prüfbericht bleibt unverändert. + +**iCal-Praxistest vorbereitet (27.10.2026):** Auf dem bestehenden Testsystem wurde für Wohnung 1 ein reiner FeWo-direkt-Exportkanal (ID 1) angelegt: keine Importadresse, keine Mailabsender-Zuordnung, keine manuellen Sperraufgaben. HTTPS-Export und Ablehnung eines falschen Tokens geprüft; zwei Abrufe mit zwei vorhandenen Ereignissen bytegleich. Die vertrauliche URL liegt ausschließlich lokal in der Git-ignorierten Datei `storage/app/private/ical-praxistest/export-url.txt`. Vorhandene Export-/Herkunftstests erfolgreich (2 Tests, 13 Assertions). Offline-Vergleich unter `scripts/compare-ical.py` vorbereitet und geprüft. [Ablauf und Nachweise](architecture/ical-praxistest-vorbereitung-2026-10-27.md). **Keine Testsperre angelegt, keine Portalverknüpfung, kein Rückimport, keine Buchung/Sperre geändert.** Der Feed enthält bereits die manuelle Sperre 31.10.–08.11.2026 und die bestätigte Buchung 14.–17.11.2026; ihre Übertragung ist vor einer Verknüpfung zu beachten. Nächster Schritt nur nach ausdrücklicher Freigabe des Nutzers. + +**Konzeptphase Vermietung (26.10.2026):** [Arbeitsentwurf](architecture/konzept-vermietung/README.md) auf Grundlage der fachlichen Bestandsdokumentation angelegt: unterschiedliche Workflows und Portale, Vorprüfung, individuelle Kommunikation, automatische Kundenbindung/Loyalty, Marketing und Automatisierungsbefugnisse. Enthält eine offene Entscheidungsliste, Arbeitsphasen und durchgängige Szenarien. Neue Regeln und Programmparameter sind Vorschläge, noch keine beschlossenen Geschäftsregeln oder umgesetzten Funktionen. Nächste fachliche Vertiefung: gewünschte Automatisierungstiefe und tatsächlich genutzte Portale klären. + **Fachliche Funktionsdokumentation (26.10.2026):** [docs/architecture/README.md](architecture/README.md) führt durch die vorhandenen Funktionen nach fachlichen Ebenen und Bereichen. [Planung und offene Punkte](architecture/planung-und-offene-punkte.md) trennt geplante Erweiterungen, Optionen und noch nötige Inbetriebnahme. Abgeglichen mit dem lokalen Anwendungsstand; keine Auslieferung durch diese Dokumentationsarbeit. Neu festgehaltene offene Abweichung: Sonderangebote können im aktuellen Preisrechner die absolute Mindestnächtezahl umgehen (Details: [Preise und Angebote](architecture/preise-und-angebote.md)). **Mandantenabschluss (26.10.):** Beide Themes nutzen Website-Logo/Favicon und die gewählte Bildwelt, auch für Bildplatzhalter. HTML- und Textmails tragen den eigenen Namen; HTML bettet das Dokumentlogo ein. Vertragsdateien liegen getrennt unter `contracts/tenants//bookings//`; Export/Löschung berücksichtigen Website-Medien, Bildkonvertierungen und Dokumentversionen. Bestehende flache Vertragsdateien bleiben lesbar; mehrdeutig von mehreren Mandanten referenzierte Altdateien stoppen die Löschung. Marken-Uploads erlauben PNG/WebP bzw. PNG/ICO; SVG wird ausschließlich aus geprüften Repository-Quellen importiert. `sites:import-stommer-brand ` übernimmt die bisherige Marke nur für Stommer, wiederholbar und ohne vorhandene Uploads zu ersetzen. @@ -68,6 +76,8 @@ ## 2. Stand auf stommer.info (Testbetrieb) ## 3. Offen +**iCal-Kanalkonfiguration:** Lokale Erweiterung und Tests fertig, Auslieferung/MariaDB-Prüfung und praktische Portalabnahme offen; Details und verbleibende Risiken im [Umsetzungsdokument](architecture/ical-kanalkonfiguration.md). Keine automatische Bestandsmigration oder Freigabe echter Kalenderverbindungen. + **Entscheidungen und Inhalte (Betreiber)** - Impressum und Datenschutzerklärung werden separat erstellt; dann unter Webseite › Texte › Rechtliches eintragen. - Mietbedingungen, Storno-Regeln, AGB; Texte zu Angebot und Annahme, einschließlich der Beschriftung des Annahme-Buttons, fachkundig freigeben lassen (Webseite › Texte). @@ -93,6 +103,8 @@ ## 3. Offen ## 4. Nächste Schritte (Vorschlag) +Für die neue iCal-Erweiterung zuerst den bestehenden Kanalbestand und die Migration auf dem Zielsystem prüfen und die Auslieferung ausdrücklich freigeben. Anschließend reale Verbindungen und den Wechsel in den regulären Modus einzeln nach dem [Freigabeablauf](architecture/ical-kanalkonfiguration.md#11-neues-portal-und-kontrollierte-freigabe) abnehmen; die bestehende Exportadresse wurde durch die lokale Umsetzung nicht verändert. + 1. Cronjob einrichten; SMTP einschalten und mit `mail:test` prüfen (Mails landen wegen Testbetrieb nur bei Lars); Konto für Brigitte anlegen. 1a. Vor dem Go-Live: System › Betrieb auf „scharf geschaltet“ stellen – erst dann erhalten Gäste die Mails. Beim Go-Live außerdem unter System › Betrieb › Adressen Kontakt-/Antwortadresse und Benachrichtigungen von fewo@stommer.de auf **info@fewo-stommer.de** umstellen (Entscheidung 23.10.2026; Absender ist bereits info@fewo-stommer.de). 2. Brigitte probt Anfrage → Angebot → Annahme mit einem eigenen Test (Angebotslink über die Aktion „Angebotslink“). diff --git a/docs/architecture/ical-kanalkonfiguration.md b/docs/architecture/ical-kanalkonfiguration.md new file mode 100644 index 0000000..466e3c0 --- /dev/null +++ b/docs/architecture/ical-kanalkonfiguration.md @@ -0,0 +1,222 @@ +# Generische iCal-Integration und konfigurierbare Portalkanäle + +Stand: 27.10.2026 · lokale Implementierung auf `feature/ical-portalkanaele` · **noch nicht ausgeliefert** + +**MVP-Ergänzung im Folgeauftrag:** [Bereitstellung und Benutzung](ical-mvp-inbetriebnahme-2026-10-27.md) ergänzt die automatische Exportlink-Erzeugung in der Oberfläche, persönliche Belegungszuordnung, archivierte UID-Identität, konfigurierbares Echoverhalten und konkrete Inbetriebnahme. Die nachfolgende ursprüngliche GAP-Analyse dokumentiert die erste Ausbaustufe; Aussagen über fehlende manuelle Zuordnung sind durch die MVP-Ergänzung erweitert. Der tatsächliche Auslieferungsstand wird im verlinkten Bericht nachgeführt. + +## 1. Gültigkeit und Nachweisstand + +Die vorhandene Kanalverwaltung, der Connector `ical`, Import, Export, Portal-Mails, Aufgaben und Protokolle wurden erweitert. Es gibt keine separate FeWo-direkt- oder Ostseeklar-Synchronisation. Ein weiterer Anbieter benötigt keine Codeänderung, wenn er das unten beschriebene Kalenderprofil unterstützt. + +| Ebene | Stand | +|---|---| +| Bisher dokumentiert | Der [Prüfbericht vom 27.10.2026](ical-synchronisation-pruefung-2026-10-27.md) beschreibt den unveränderten Ausgangsstand bei `6fe5bbc`. Er bleibt als historischer Befund unverändert. | +| Jetzt implementiert | Die in diesem Dokument beschriebenen Erweiterungen liegen lokal vor. Eine neue Schema-Migration ist enthalten. | +| Automatisiert verifiziert | Synthetische Kalender, simulierte HTTP-Antworten, simulierte Mails, Livewire-Verwaltung und SQLite-In-Memory-Datenbank; siehe Abschnitt 10. | +| Von Lars berichtet | Eine FewoPortal-Sperre wurde bei FeWo-direkt importiert und angezeigt, erschien nicht im untersuchten FeWo-direkt-Export und verschwand dort nach ihrer Löschung in FewoPortal. | +| Nicht unabhängig praktisch verifiziert | Abruf- und Löschverhalten echter Portale, deren UID-Verarbeitung, tatsächliche laufende Zuordnungen, MariaDB-Migration und Einrichtung des regelmäßigen Serverbetriebs. | + +In diesem Umsetzungsschritt wurden keine Server, echten Kalender, Buchungen, Sperren oder Portalverknüpfungen verändert. Die lokale Anwendungsdatenbank wurde nicht migriert. Die Migration lief ausschließlich innerhalb isolierter Tests. + +Die vom Nutzer berichtete FeWo-direkt-Beobachtung gilt für diesen konkreten Versuch. Sie ist keine allgemeine Zusicherung für FeWo-direkt, andere Inserate oder andere Portale. Unterschiedliche UIDs bei ähnlichen Terminen in FeWo-direkt und Ostseeklar belegen weder eine gemeinsame Identität noch verschiedene Aufenthalte. + +## 2. Kompakte GAP-Analyse + +| Anforderung | Ausgangsstand | Lokale Erweiterung | +|---|---|---| +| Beliebige Portale je Wohnung | Generischer Connector, freie Namen und mehrere Kanäle vorhanden | Weiterverwendet; Buchungsmodell und Einrichtungsstatus ergänzt | +| Richtungen getrennt steuern | Gemeinsame Aktivität, Import abhängig von URL | Eigene Import- und Exportschalter, zusätzlich Setup/Aktiv/Pausiert | +| Testbetrieb | Regulärer Export außer eigenen Kanal-Sperren | Expliziter Testmodus ohne Fremdbelegungen, auch für Portal-Aufgaben | +| Herkunft | Kanal und externe UID an Sperren | Bekannter Ursprung zusätzlich; Import-/Ursprungskanal an Buchungen; Prüfung auf dieselbe Wohnung | +| Pause | Abschaltung des Feeds konnte dessen Erreichbarkeit beenden | Letzten gültigen Stand weiterliefern; ohne Stand HTTP 503 statt leerem Kalender | +| Beschädigter Feed | Teilweise Verarbeitung konnte wie verschwundene Ereignisse wirken | Gesamten unterstützten Kalender vor jeder Bestandsänderung prüfen | +| Fehlende Ereignisse | Sofortige Entfernung nach erfolgreichem Abruf | Zwei bestätigende erfolgreiche Kalenderstände; mehr als fünf fehlende Ereignisse zurückhalten | +| Dubletten | Doppelte UID im selben Lauf nicht ausreichend abgesichert | Identische Belegung je UID einmal übernehmen; widersprüchliche UID ablehnen; beschädigten Altbestand erhalten | +| Mail und iCal | Zuordnung teilweise über Termine | Nur gemeinsame Referenz/UID zusammenführen; unklare Repräsentationen behalten und markieren | +| Termine und Entsperrung | Verzögerte Observer konnten alte Daten verlieren; einzelne Löschung konnte zu viel freigeben | Ereigniswerte vor Commit sichern; erst danach Aufgaben; Entsperrung nur für aktuell freie Nächte | +| Tokenwechsel | Keine kontrollierte Übergangsphase | Bewusste Rotation mit befristeter Gültigkeit des bisherigen Links | +| Überwachung | Erfolgszeit und Fehler vorhanden | Fehlerzeit, Ereigniszahl, Warnungen, Prüffälle, Exportzustand und letzter beobachteter Feedabruf | +| Erstimport | Kein eigener Migrationsprozess | Bestehende Belegungen erhalten, Überlappungen markieren; keine automatische Datumszusammenführung | + +## 3. Kanal je Wohnung konfigurieren + +Ort: **Verwaltung → Wohnung → Portale & Kanäle**. Der Kanal gehört zur geöffneten Wohnung und ihrem Mandanten. Namen wie „FeWo-direkt“ und „Ostseeklar“ sind freie Konfiguration; der Connector bleibt `ical`. + +| Einstellung | Bedeutung | +|---|---| +| Name | Frei gewählter Portalname | +| Kanalstatus | Noch nicht eingerichtet, aktiv oder pausiert | +| Buchungsmodell | Vermittlung/Anfrage, Portalbuchung oder gemischt; derzeit nur fachliche Einordnung | +| Importadresse | Vertrauliche Exportadresse des Portals; verdeckt mit bewusster Einblendung | +| Import aktiviert | Regelmäßigen oder manuellen iCal-Import erlauben; nur bei aktivem Kanal und freigeschaltetem Mandantendienst | +| Export aktiviert | Aktuellen Kalender für diesen Kanal erzeugen; ausgeschaltet gilt die sichere Pause aus Abschnitt 5 | +| Exportmodus | Testbetrieb oder reguläre Synchronisation | +| Erwarteter externer Abrufabstand | Information in Minuten; unbekannt darf leer bleiben | +| Mailabsender | Optionale Zuordnung für den bestehenden separaten Mail-Schnellweg | +| Zusätzlich von Hand sperren | Zusätzliche Portal-Aufgaben für einen aktiven exportierenden Kanal | +| Vermieterkalender | Optionaler Einstieg zur Handpflege | + +Neue Kanäle starten mit **Status „Noch nicht eingerichtet“, Import aus, Export aus und Testmodus**. Für einen eingeschalteten Import ist eine Importadresse erforderlich. Ein Kanal mit vorhandenem Importbestand darf seine Quelladresse nicht unbemerkt wechseln. Dafür einen neuen Kanal anlegen oder die Bestandsumstellung gesondert planen. Die Oberfläche bietet keine Kanallöschung mehr; eine Pause erhält Belegung und Herkunft. + +Import-only, Export-only und beide Richtungen sind unabhängig wählbar. Der Kanalstatus „Pausiert“ stoppt beide Richtungen unabhängig von den vorgemerkten Richtungsschaltern. Der iCal-Importschalter steuert nicht den separaten Portal-Mail-Dienst: Bei aktivem Kanal und eingetragenen Absendern kann dieser weiterhin Sperren erzeugen. Zum vollständigen Pausieren den Kanalstatus verwenden. + +Importadresse und Token sind keine normalen Listenwerte. Die Exportadresse ist über **„Vertraulicher Exportlink“** bewusst abrufbar und kopierbar. Token, Snapshot und Einstellungen sind bei normaler Modellserialisierung ausgeblendet. Der Export enthält Belegungen mit `SUMMARY:Belegt`, keine Gastnamen, Preise oder internen Sperrgründe. Die Adresse bleibt ein Zugangsschlüssel; Serverzugriffsprotokolle und Empfänger können sie dennoch kennen. + +## 4. Exportmodi und Herkunft + +| Belegung | Testbetrieb | Regulär | +|---|---|---| +| Eigene belegende Buchung | Ja | Ja | +| Eigene noch gültige Vormerkung | Ja, nach bestehender `occupying()`-Regel | Ja, nach derselben Regel | +| Eigene manuelle Sperre | Ja | Ja | +| Importierte Kalender- oder Mail-Sperre | Nein | Ja, außer Importkanal oder bekanntem Ursprung des Zielkanals | +| Buchung mit gespeichertem Import-/Ursprungskanal | Nein | Ja, außer Import-/Ursprungskanal des Zielkanals | +| Buchung mit fremdem/unbekanntem Quellenwert ohne Kanalangabe | Nein | Enthalten; die fehlende Kanalzuordnung verhindert einen gezielten Herkunftsausschluss | + +Im Testbetrieb gelten nur die eigenen Quellen `website`, `manual`, `phone`, `direct`, `email` ohne Import- und Ursprungskanal als eigene Buchung. Eine Portalbuchung darf bei späterer Übernahme deshalb ihre Herkunft nicht verlieren. Die Übernahme zu einer vollständigen Buchung selbst ist weiterhin eine spätere Funktion. + +**Fremdbelegungen blockieren im Testbetrieb intern unverändert. Ihre Weitergabe an andere Portale ist jedoch ausgeschlossen. Der Testbetrieb gewährleistet somit keine vollständige kanalübergreifende Sperrung.** Diese Regel gilt auch für neu erzeugte Aufgaben zur manuellen Pflege und deren automatische Übergabe. Bereits früher an Portale übertragene Sperren werden durch die Moduswahl nicht außerhalb des Kalenders automatisch bereinigt. + +Der reguläre Modus wird ausschließlich durch eine bewusste Auswahl aktiviert. Kein Importergebnis und kein erfolgreicher Test schaltet ihn automatisch ein. + +Der konkrete Sofortbuchungsfall ist damit abgesichert: Ein FeWo-direkt-Ereignis erhält beim Import die ID seines konfigurierten FeWo-direkt-Kanals. Dessen Export lässt die Sperre aus. Im Testbetrieb lassen auch alle anderen Feeds diese Fremdsperre aus; regulär geben sie sie weiter, sofern sie nicht selbst der bekannte Ursprung sind. + +Bekannte Herkunft wird getrennt gespeichert: `BlockedPeriod.channel_id` ist der Importkanal; `origin_channel_id` ist ein zusätzlich bekannter Ursprung. `external_uid` ist die Kennung innerhalb dieses Kanals; `id` ist die lokale Sperr-ID. An Buchungen stehen `import_channel_id` und `origin_channel_id` bereit. Der iCal-Import setzt keinen geratenen ursprünglichen Buchungskanal. Er übernimmt auch keinen Gastnamen aus `SUMMARY` als Buchungsinformation. Die Verwaltung zeigt Importkanal, bekannten Ursprung, UID und Prüffälle; die interne ID ist einblendbar. + +Der bisherige UID-Suffixfilter bleibt erhalten: Ereignisse mit unserer UID-Endung werden nicht erneut als Fremdsperre importiert. Verändert ein Portal die UID, ist dieser Nachweis verloren. Ein Echo über einen anderen Kanal mit neuer UID wird nicht zuverlässig erkannt. Gleiche oder überlappende Termine werden deshalb niemals allein als gemeinsame Identität behandelt. + +## 5. Sichere Pause und Tokenwechsel + +### Import pausieren + +Vorhandene Sperren bleiben bestehen. Es gibt keinen Abruf und keine Löschung wegen der Pause. Die Bestätigungszähler für fehlende Ereignisse werden beim Umschalten über die Verwaltung zurückgesetzt. Nach Reaktivierung sind erneut erfolgreiche vollständige Kalenderstände erforderlich. + +### Export pausieren + +Jeder erfolgreiche aktuelle Abruf speichert den validierten Export als letzten gültigen Stand. Nach Ausschalten des Exports oder Pausieren des Kanals bleibt genau dieser Stand unter derselben Adresse erreichbar. Änderungen während der Pause verändern ihn nicht. Wurde noch nie abgerufen, sichert die Konfigurationsaktion beim Übergang aus einem aktiven Export dessen bisherigen Kalender. + +Ohne gespeicherten Stand wird **HTTP 503** mit `Retry-After: 300` geliefert. Es wird kein leerer Kalender als Abschaltung gesendet. Ein eingefrorener Stand kann konservativ zu lange sperren und enthält keine neuen Änderungen während der Pause. Er ist keine fortlaufende Synchronisation. Bei Reaktivierung wird beim nächsten Abruf wieder aktuell erzeugt. `X-Fewo-Export-State` kennzeichnet `live` oder `frozen`. + +Die vorhandene Mandantendienst-Sperre bleibt übergeordnet: Entzug des gesamten Portal-Dienstes liefert weiterhin 404. Sie ist kein Ersatz für die hier beschriebene betriebliche Kanalpause. Wie ein Portal HTTP-Fehler behandelt, muss praktisch geprüft werden; unsere Antwort allein garantiert dessen Bestandsverhalten nicht. + +### Token rotieren + +Die Aktion verlangt eine bewusste Bestätigung. Der neue Link wird sofort gültig; der bisherige bleibt für die gewählte Übergangszeit von 24 bis 720 Stunden gültig, standardmäßig 168 Stunden. Beide liefern denselben Kanal mit demselben Betriebszustand. Eine weitere Rotation während der laufenden Übergangsphase wird abgewiesen. + +Den neuen Link innerhalb dieser Frist selbst beim richtigen Portal eintragen und dort die Übernahme prüfen. Nach Fristablauf endet die Gültigkeit des bisherigen Links. Es gibt keinen automatischen Eintrag im Portal und keinen Nachweis, welchen der beiden Links das Portal tatsächlich verwendet. Die Frist und der nötige externe Wechsel sind in der Aktion ausdrücklich benannt. + +## 6. Import, Änderungen und Entfernung + +Vor Bestandsänderungen muss der vollständige HTTP-Abruf erfolgreich sein und der gesamte unterstützte Kalender validieren. Fehler erhalten Sperren und bisherige Erfolgszeit. Die neue Fehlerzeit und eine Meldung ohne Importtoken werden gespeichert. + +Das unterstützte Profil umfasst einen vollständigen `VCALENDAR` mit `VERSION:2.0`, `PRODID`, geschlossenen Komponenten und einzelnen `VEVENT`s mit UID, gültigem UTC-`DTSTAMP` und positivem Übernachtungszeitraum. Gefaltete UTF-8-Zeilen, ganztägige Daten, unterstützte Zeitzonen und Zeitangaben werden verarbeitet. Fehlendes `DTEND` bedeutet nur bei einem ganztägigen Ereignis eine Nacht. `CANCELLED` und `TRANSPARENT` sind nicht belegend. Ein gültiger leerer Gesamtkalender ist möglich. + +HTML, abgeschnittene oder widersprüchliche Strukturen, ungültige Daten, fehlende Identität/Zeitstempel und widersprüchliche doppelte UIDs lehnen den ganzen Stand ab. Identische Belegungen derselben UID werden einmal verarbeitet. Serien (`RRULE`, `RDATE`, `EXDATE`, `RECURRENCE-ID`), `DURATION` sowie einzelne Kalendernachrichten statt Gesamtkalendern werden abgewiesen. Das ist ein bewusst begrenztes Belegungsprofil, keine vollständige Implementierung aller iCalendar-Möglichkeiten. Die Kompatibilität der echten Feeds ist vor Aktivierung zu prüfen. + +| Ereignis | Verarbeitung | +|---|---| +| Neue UID im Kanal | Neue zugeordnete Sperre | +| Bekannte UID mit gleichem Zeitraum | Keine zweite Sperre | +| Bekannte UID mit geändertem Zeitraum | Dieselbe lokale Sperre aktualisieren; alte und neue Termine für Aufgaben erhalten | +| Fehlende zukünftige UID | Beim ersten erfolgreichen Fehlen erhalten; beim zweiten bestätigenden erfolgreichen Fehlen entfernen | +| UID wieder vorhanden | Fehlenszähler zurücksetzen | +| Mehr als fünf zukünftige Ereignisse fehlen | Keine automatische Entfernung; Prüffälle und Warnung | +| Abruf oder Validierung fehlgeschlagen | Keine Bestandsänderung; keine Entsperrung | +| Vorhandene importierte Dubletten/fehlende UID im Altbestand | Abgleich abbrechen und Bestand erhalten; manuelle Prüfung nötig | +| Vergangene Ereignisse | Nicht neu importieren; alte vergangene Sperren werden hier nicht automatisch bereinigt | + +Die Grenzen stehen in `config/channels.php`: `removal_confirmation_runs = 2`, `max_automatic_removals = 5`. Wiederholte erfolgreiche Abrufe können denselben vom Portal zwischengespeicherten Stand bestätigen. Ein formal gültiger, aber inhaltlich unvollständiger Feed mit höchstens fünf verschwundenen Ereignissen kann daher nach zwei erfolgreichen Abrufen weiterhin zu einer falschen Entfernung führen. Die Schutzregeln können fehlende Herkunfts- oder Vollständigkeitsgarantien des Portals nicht ersetzen. + +Pro Kanal verhindert eine Cache-Sperre parallele Abrufe. Vor Anwendung werden Kanalkonfiguration und Wohnung unter Datenbanksperre geprüft. Ändert sich die Quelladresse oder wird der Import während des Abrufs pausiert, wird der Stand nicht übernommen. Die Cache-Sperre ist auf 120 Sekunden befristet; dies ersetzt keinen noch ausstehenden Belastungs- und Parallelitätstest auf dem Zielsystem. + +## 7. Erstimport, Mail-Sperren und Doppelsperren + +Beim Erstimport werden lokale Belegungen weder gelöscht noch anhand gleicher Daten zusammengeführt. Überschneidungen mit Buchungen, manuellen Sperren oder anderen Kanälen sowie mehrere Repräsentationen desselben Kanals bleiben sichtbar und werden als Prüffälle markiert. Auch eine nicht zugeordnete Mail-Sperre mit inzwischen anderem Zeitraum bleibt erhalten und wird zur Prüfung vorgemerkt. Prüffälle sind Hinweise zur persönlichen Bestandsklärung; es gibt keinen automatischen Migrations- oder Auflösungsassistenten. + +Mail- und Kalender-Sperre werden nur bei einer gemeinsamen Kennung zusammengeführt: `email:` muss zur späteren Kalender-UID passen. Dann wird dieselbe lokale Sperre zu einer Kalender-Sperre und ein geänderter Zeitraum übernommen. Stimmt die Referenz nicht mit der Portal-UID überein, bleiben beide erhalten. Ein gemeinsam belegter Zeitraum genügt nicht als Nachweis. Eine Storno-Mail ohne passende Referenz gibt keine Sperre nur anhand der Daten frei. Nach Übernahme in den Kalenderbestand steuert der Kalender dessen spätere Entfernung; eine Mail hebt Kalender-Sperren nicht direkt auf. + +Bei mehreren passenden Kanälen desselben Mailabsenders wird keine erste Wohnung geraten. Die Kanäle erhalten eine Warnung. Für mehrere Inserate desselben Portals ist eine verlässliche Inserats-/Wohnungszuordnung der Mails weiterhin gesondert zu konzipieren. Die bestehende Absendererkennung allein ist außerdem kein kryptographischer Echtheitsnachweis einer Portal-Mail. + +## 8. Konsolidierte Portal-Aufgaben + +Aufgaben entstehen erst nach erfolgreichem Datenbank-Commit. Die Observer sichern vorher alte und neue Termine, Import- und Ursprungskanal. Ein Rollback erzeugt keine Aufgaben. Herkunftskanal und bekannter Ursprung werden ausgeschlossen; im Testbetrieb werden Fremdbelegungen nicht als neue Aufgaben weitergegeben. + +Bei einer Entsperrung wird der aktuelle Gesamtbestand der Wohnung berücksichtigt. Nur zusammenhängende tatsächlich freie Nächte erhalten eine Entsperraufgabe. Überlappende Sperren und belegende Buchungen bleiben berücksichtigt. Vor der Automationsübergabe und beim Erledigen einer Entsperraufgabe wird die Verfügbarkeit erneut geprüft; inzwischen belegte Aufgaben werden verworfen. Überholte Sperraufgaben mit inzwischen freien Nächten werden vor einer erneuten Automationsübergabe ebenfalls verworfen. Pausierte Exporte werden nicht an eine Automation übergeben. + +Eine bereits abgeschickte Automationsanweisung oder eine von Menschen außerhalb der Anwendung vorgenommene Änderung kann nicht zurückgerufen werden. Zwischen letzter Prüfung und Ausführung im Portal verbleibt ein Zeitfenster; ein externer Empfänger muss Reihenfolge, Wiederholung und aktuellen Zustand berücksichtigen. Eine tatsächliche Portal-Automation wurde hier weder eingerichtet noch getestet. + +## 9. Überwachung und Abrufzeiten + +Die Kanalliste zeigt Importzustand, letzten erfolgreichen Import, letzte Fehlerzeit, Anzahl zuletzt übernommener Ereignisse, Warnungen, Prüffallzahl, Exportmodus und Exportzustand. Die letzten 30 Protokolle sind einsehbar. Ein manueller Lauf bleibt für eingeschaltete eingerichtete Importe verfügbar. + +Unser Aufgabenplan sieht `channels:sync` alle fünf Minuten vor. Der erwartete externe Abrufabstand ist dagegen nur eine Vermutung zum Portal und steuert diesen Plan nicht. Ohne eingerichteten Scheduler erfolgt kein regelmäßiger Abgleich. Der bisher dokumentierte Einrichtungsbedarf auf dem Testserver wurde hier nicht verändert. + +`last_export_requested_at` zeigt einen beobachteten Abruf dieser Feedadresse. Die Anzeige heißt ausdrücklich **„Letzter Feedabruf (Client unbekannt)“**. Ein eigener Test, Monitor oder weitergegebener Link kann denselben Abruf auslösen. Der Zeitpunkt beweist weder den Portalclient noch eine erfolgreiche Verarbeitung dort. Getrennte bestätigte Portal-Synchronisationszeiten sind nicht implementiert. Auch Prüffälle müssen persönlich bearbeitet werden; ein technisch erfolgreicher Import bedeutet nicht konfliktfreien Bestand. + +## 10. Automatisierte Nachweise und reproduzierbarer Testplan + +Voraussetzungen: installierte Projektabhängigkeiten und PHP 8.4. Die vorhandene `phpunit.xml` verwendet `APP_ENV=testing`, SQLite `:memory:`, Array-Cache, Array-Mailer und synchrone Testqueue. Kein `artisan migrate`, `channels:sync` oder Postfachkommando gegen eine eingerichtete Anwendungsdatenbank ausführen. + +```powershell +php vendor/bin/phpunit --do-not-cache-result tests/Feature/GenericChannelIntegrationTest.php +php vendor/bin/phpunit --do-not-cache-result tests/Feature/ChannelSyncTest.php tests/Feature/PortalMailTest.php tests/Feature/TenantServiceGateTest.php tests/Feature/TenantScheduleTest.php +php vendor/bin/phpunit --do-not-cache-result +``` + +Die neue Datei enthält 44 Fälle einschließlich Datenvarianten. HTTP-Zugriffe werden darin simuliert und nicht simulierte Anfragen verboten; es werden ausschließlich synthetische Kalender und Buchungen angelegt. Die bestehenden Kanal- und Mailtests wurden an die validierten Kalender und die sichere Zuordnung angepasst. + +| Reproduzierbares Szenario | Erwartung und Nachweis | +|---|---| +| Neuer Kanal, beide Richtungsschalter in vier Kombinationen | Sichere Defaults, unabhängige Richtungen; `test_new_channel_has_safe_defaults…`, `test_directions_are_independent` | +| Eigene/Fremdbelegung, auch als Buchung | Testexport nur eigene; Fremdsperre intern belegt; `test_test_mode_exports_only_own_occupations…` | +| Regulär mit Importkanal und bekanntem Ursprung | Beide Zielkanäle ausgeschlossen; `test_regular_mode_excludes_both…` | +| Erstabruf, Pause, neue interne Belegung, Reaktivierung | Eingefrorener Stand identisch, danach aktuell; ohne Stand 503; `test_paused_export_freezes…`, `test_pause_before_first_request…` | +| Identischer Feed, identische doppelte UID, eigene UID-Endung | Keine Dublette, kein Echo; `test_repeated_import_and_identical_duplicate_uids…` | +| Geänderte UID-Termine | Lokale ID bleibt; alte Entsperr- und neue Sperrtermine stimmen; `test_changed_dates_keep_identity…` | +| Fehlende Ereignisse und Wiederauftauchen | Zwei erfolgreiche Bestätigungen nötig, Reset bei Wiederauftauchen/Pause; `test_missing_events_require_two…` | +| Mehr als fünf fehlende Ereignisse | Bestand bleibt und Warnung; `test_large_disappearance_is_held…` | +| Elf fehlerhafte Feedvarianten und HTTP 403 | Keine Freigabe, keine Erfolgszeitänderung, kein Token in Fehlermeldung; `test_invalid_snapshot…`, `test_failed_fetch…` | +| Mail mit/ohne gemeinsame Kennung, auch nach Verschiebung | Nur belegte Identität zusammenführen; referenzlose Stornierung erhält Sperre; `test_mail_and_calendar_merge_only…`, `test_unidentified_nonoverlapping…`, `test_cancellation_without_shared_reference…` | +| Überlappende Belegungen löschen/ändern | Entsperraufgaben nur freie Teilzeiträume; `test_unblock_tasks_release_only_currently_free_nights` | +| Verzögerte Aufgabe, inzwischen geändert | Keine überholte Sperre/Entsperrung an Automation; `test_outdated_block_task…`, `test_outdated_unblock_task…` | +| Transaktion zurückrollen, parallelen Kanalabruf sperren | Keine Aufgaben nach Rollback, kein zweiter Abruf; `test_rolled_back_occupations…`, `test_a_channel_lock…` | +| Falsche Wohnung, mehrere Wohnungen, mehrdeutige Mailabsender | Keine falsche Herkunftszuordnung, kein gemeinsamer Bestand; `test_foreign_channel_provenance…`, `test_two_properties…`, `test_ambiguous_mail_sender…`; ergänzend vorhandene Mandantenregressionstests | +| Verwaltung bedienen | Richtungen und geschützte URL bearbeitbar, Herkunft und Prüffall sichtbar; `test_admin_can_configure…`, `test_admin_can_view…` | +| Token rotieren und Frist überschreiten | Alter/neuer Link während Übergang, alter danach ungültig; zweite Rotation verhindert; `test_token_rotation…`, `test_second_rotation…` | +| Migration mit synthetischem Bestand zurück/vor | Richtungen, Exportumfang, Token und Sperrbestand erhalten; `test_upgrade_preserves_existing…` | +| Langer UTF-8-Wohnungsname | RFC-Zeilenfaltung mit unveränderten Nächten; `test_export_folds_long_utf8_lines…` | + +Die abschließenden Gesamtergebnisse stehen im [Projektstand](../STATUS.md). Automatisierte Nachweise ersetzen keine praktische Portalabnahme. + +## 11. Neues Portal und kontrollierte Freigabe + +1. Zunächst mit synthetischen Feeddateien und simuliertem HTTP prüfen, ob das Portalprofil unterstützt wird. Bei Serien oder abweichenden UID-/Zeitstempelangaben keine echte Verbindung einschalten. +2. Nach ausdrücklicher Freigabe zur Auslieferung die reguläre Pipeline und eine gesicherte Migration auf dem Zielsystem verwenden. Vorher MariaDB-Verhalten, Sicherung und bestehende Kanäle prüfen. In dieser Sitzung wurde dies nicht ausgeführt. +3. Einen Kanal an der richtigen Wohnung anlegen, Namen und Buchungsmodell setzen. Status zunächst nicht eingerichtet, beide Richtungen aus, Testmodus. Den benötigten Mandantendienst und die regelmäßigen Hintergrundläufe prüfen. +4. Bestehende Portal- und lokale Belegungen mit Herkunft aufnehmen. Alte manuelle Fremdsperren, noch wirksame Links und eventuell bereits übertragene eigene Sperren persönlich abgleichen. Keine bestehenden Sperren als automatische Bereinigung löschen. +5. Vor einer neuen echten Import-/Exportverknüpfung ausdrücklich freigeben lassen, welche Wohnung, welcher Kanal, welche Richtung und welche Bestandswirkung getestet werden darf. Vertrauliche Adressen nur an den vorgesehenen Empfänger geben. +6. Im freigegebenen Testbetrieb eine eigene synthetische Sperre, deren Änderung und Entfernung prüfen. Das Portal muss den Export tatsächlich übernehmen. Pausierung, Wiederaufnahme und HTTP-Fehlerverhalten am Portal prüfen. Dabei keine echten Aufenthalte verwenden. +7. Für den Sofortbuchungsfall einen ausdrücklich freigegebenen synthetischen Portalvorgang verwenden: Import erzeugt eine interne Sperre; der eigene Zielkanal enthält sie nicht erneut. Im Testmodus darf kein anderer Feed sie weitergeben. Eine Mailrepräsentation nur bei gemeinsamer Kennung zusammenführen; sonst Prüfung sichtbar belassen. +8. Erst nach geklärtem Bestand, Herkunft und Echoverhalten den regulären Modus für jeden Kanal bewusst freigeben. Auch die Übergangsfreigaben beim Entfernen bisher exportierter Fremdsperren oder beim Wechsel einer Quelle vorher prüfen. Gültige Buchungen dürfen dadurch nicht extern geöffnet werden. +9. Die dokumentierte FeWo-direkt-Beobachtung für jede relevante Verbindung erneut prüfen. UIDs und tatsächliche Portalstände belegen, Zeitpunkte und Grenzen festhalten. Ein GET-Zeitpunkt allein genügt nicht. + +## 12. Migration, offene Risiken und Codeverweise + +Die neue Migration ergänzt nur Schema und Kanalsteuerungswerte. Bestehende aktive Kanäle behalten ihren bisherigen Exportumfang als **regulärer Modus** und ihre Token; Import bleibt nur mit bisher aktiver Konfiguration und vorhandener URL eingeschaltet. Inaktive Kanäle werden pausiert. Das ist eine Kompatibilitätsübernahme des zuvor bereits regulären Exports, keine automatische Hochstufung eines Testkanals nach erfolgreichem Versuch. Neue Kanäle starten stets im Testmodus. Belegungen werden weder automatisch migriert noch zusammengeführt oder gelöscht. + +Vor der ersten Auslieferung vorhandene Kanäle deshalb einzeln prüfen. Ein bestehender pausierter Kanal hat zunächst möglicherweise keinen Snapshot und liefert dann 503. Ein sofortiger erzwungener Wechsel aller bestehenden Feeds auf den Testmodus könnte fremde Sperren extern freigeben und wird nicht durchgeführt. + +Offen bleiben insbesondere UID-Änderungen über mehrere Portale, unbekannte Alt-Herkunft, sichere mehrfache Inseratszuordnung in Mails, inhaltlich unvollständige aber formal gültige Feeds, externe Abrufverzögerungen, Prüfung der echten Exportprofile, Zielsystem-/MariaDB- und Parallelitätstests sowie das Restzeitfenster bis zur manuellen oder automatisierten Ausführung. Konfliktmails können bei wiederholt vorhandenem Konflikt erneut entstehen. Prüffälle werden nicht automatisch als fachlich geklärt entfernt. Portalbuchungen werden weiterhin nicht mit Gästen, Preisen und Zahlungen als vollständige Buchung übernommen. Ein vollständiger Channel-Manager oder ein fertiger Portal-Bot ist nicht Bestandteil dieses Schritts. + +| Verantwortung | Konkreter Code | +|---|---| +| Konfiguration und sichere Übergänge | [`ConfigureChannel::handle`](../../app/Actions/ConfigureChannel.php), [`Channel`](../../app/Models/Channel.php), [`ChannelsRelationManager`](../../app/Filament/Resources/Properties/RelationManagers/ChannelsRelationManager.php) | +| Auswählen und Erzeugen des Exports | [`ICalFeed::build`](../../app/Channels/ICal/ICalFeed.php), [`ICalExport::build`](../../app/Channels/ICal/ICalExport.php), [`ChannelController::feed`](../../app/Http/Controllers/ChannelController.php) | +| Abruf und vollständige Profilvalidierung | [`ICalConnector::fetchOccupations`](../../app/Channels/ICal/ICalConnector.php), [`ICalParser::parse`](../../app/Channels/ICal/ICalParser.php) | +| Identität, Änderung, Fehlensbestätigung und Prüffälle | [`SyncChannel::handle`](../../app/Actions/SyncChannel.php), [`config/channels.php`](../../config/channels.php) | +| Herkunft und deren Wohnungsgrenze | [`HasChannelProvenance`](../../app/Models/Concerns/HasChannelProvenance.php), [`BlockedPeriod`](../../app/Models/BlockedPeriod.php), [`Booking::isDirect`](../../app/Models/Booking.php) | +| Mailidentität und referenzbasierte Stornierung | [`ProcessPortalMail`](../../app/Actions/ProcessPortalMail.php) | +| Aufgaben nach Commit und konsolidierte Entsperrung | [`BlockedPeriodObserver`](../../app/Observers/BlockedPeriodObserver.php), [`BookingObserver`](../../app/Observers/BookingObserver.php), [`CreateChannelTasks`](../../app/Actions/CreateChannelTasks.php), [`ChannelTask::complete`](../../app/Models/ChannelTask.php) | +| Tokenrotation | [`RotateChannelToken::handle`](../../app/Actions/RotateChannelToken.php) | +| Schema und kompatible Kanalübernahme | [Migration](../../database/migrations/2026_10_27_154125_add_generic_ical_controls_and_provenance.php) | +| Ausführbare Nachweise | [`GenericChannelIntegrationTest`](../../tests/Feature/GenericChannelIntegrationTest.php), [`ChannelSyncTest`](../../tests/Feature/ChannelSyncTest.php), [`PortalMailTest`](../../tests/Feature/PortalMailTest.php), [`TenantServiceGateTest`](../../tests/Feature/TenantServiceGateTest.php), [`TenantScheduleTest`](../../tests/Feature/TenantScheduleTest.php) | diff --git a/docs/architecture/ical-mvp-inbetriebnahme-2026-10-27.md b/docs/architecture/ical-mvp-inbetriebnahme-2026-10-27.md new file mode 100644 index 0000000..5a24e6f --- /dev/null +++ b/docs/architecture/ical-mvp-inbetriebnahme-2026-10-27.md @@ -0,0 +1,69 @@ +# iCal-MVP: Bereitstellung und Benutzung + +Stand: 27.10.2026 · Auslieferung vorbereitet; tatsächlicher Auslieferungsnachweis wird nach Pipeline-Abschluss ergänzt. + +## Oberfläche und automatische Exportlinks + +Unter **Verwaltung → Wohnungen → Wohnung bearbeiten → Portale & Kanäle** wird jeder weitere Anbieter mit einem frei wählbaren Namen und der Anbindung „Kalender-Abgleich (iCal)“ angelegt. Für FeWo-direkt, Ostseeklar und weitere kompatible Anbieter gilt derselbe Ablauf. + +**Beim Speichern erzeugt FewoPortal automatisch einen eigenen dauerhaften Exportlink für diesen Kanal.** Keine Datei, manuelle Tokenanlage oder Programmierung ist nötig. Über **„Vertraulicher Exportlink“** wird die Adresse kopiert und beim externen Portal hinterlegt. Umbenennen, Pausieren und Reaktivieren ändern den Link nicht. Nur eine ausdrücklich ausgeführte Tokenrotation erzeugt eine neue Adresse mit Übergangsfrist. + +Die **Importadresse** ist die vom externen Portal bereitgestellte Kalenderadresse. Sie wird im selben Formular eingetragen; FewoPortal kann sie nicht selbst für ein fremdes Portalkonto erzeugen. Sie darf zunächst fehlen. Ein neuer Kanal startet ohne aktive Richtung und kann schrittweise eingerichtet werden. Für den normalen kanalübergreifenden Betrieb ausdrücklich **regulären Exportmodus** wählen. Der Testmodus ist ein optionales Untersuchungswerkzeug. + +Die Liste zeigt Richtungsschalter, Kanalstatus, letzte Importerfolge und Fehler, Ereigniszahl, Prüffälle, Exportmodus sowie beobachtete Feedabrufe. **„Exportumfang prüfen“** zeigt die aktuell berechnete Ereigniszahl und Importe, die wegen ungeklärter Herkunft oder bestätigter Mehrfachdarstellung nicht zusätzlich ausgegeben werden. Ein pausierter Export liefert weiterhin seinen gespeicherten Stand. + +## Bestehende Mehrfachdarstellungen klären + +Unter **Vermietung → Sperrzeiten** stehen Importkanal, UID, bekannte Herkunft, Prüffall und Belegungsführung. **„Nur Prüffälle“** grenzt die Liste ein. Die Aktion **„Belegung zuordnen / klären“** bietet: + +1. **Eigenständige Belegung bestätigen:** Die Sperre bleibt führend und wird für die regulären anderen Exportfeeds freigegeben. Einen ursprünglich bekannten Buchungskanal auswählen; unbekannte Herkunft darf unbekannt bleiben. +2. **Weitere Darstellung einer Sperre:** Eine führende Sperre derselben Wohnung mit genau demselben Zeitraum wählen. Die importierte UID bleibt nachvollziehbar gespeichert, steuert aber keine zweite Belegung und keinen zusätzlichen Export mehr. +3. **Weitere Darstellung einer Buchung:** Entsprechend eine belegende eigene Buchung zuordnen. + +Gleiche Termine lösen niemals automatisch eine Zuordnung aus. Ein Vermieter bestätigt die fachliche Identität persönlich. Verknüpfungsketten sind ausgeschlossen. Eine falsche Zuordnung lässt sich über die Bestätigung als eigenständige Belegung wieder aufheben. + +Beispiel „Reserved – Annette“ und „Belegt“, beide 23.–30.05.2027: Zunächst bleiben beide importierten UID-Datensätze erhalten. Nach persönlicher Klärung wird eine führende Belegung gewählt und die zweite Darstellung zugeordnet. Die führende Belegung steuert anschließend Verfügbarkeit, Änderungen und Stornierung. Bleibt nach ihrer Stornierung eine alte Darstellung im zweiten Portal, erzeugt sie keine dauerhafte lokale Doppelsperre. Weicht der Zeitraum einer zugeordneten Darstellung später ab, entsteht wieder ein Prüffall; die Anwendung rät keine neue Buchungsidentität. + +Entfernte Sperren werden zur Identitätserhaltung archiviert (`deleted_at`). Wiederkehrende Portal-UIDs stellen dieselbe lokale ID wieder her. Zugeordnete Darstellungen bleiben dadurch bei wiederholtem Import zugeordnet. Das ist keine automatische Löschung oder Bereinigung vorhandener externer Handpflege. + +**Wichtig für die Umstellung:** Alte manuelle Sperren im Portal verschwinden durch eine lokale Zuordnung nicht. Erst die führende Belegung und deren Ausgabe im anderen Feed prüfen, dann überholte manuelle Portalpflege einzeln abstimmen und korrigieren. Keine ungeprüfte Massenbereinigung. + +## Rückkopplungsverhalten je Kanal + +Konfigurierbar sind „Noch ungeprüft“, „Im geprüften Fall keine Weitergabe importierter Ereignisse“ und „Gibt importierte Ereignisse weiter“. Beobachtung und Nachweis werden als Text festgehalten. Die FeWo-direkt-Beobachtung von Lars gilt weiterhin nur für seinen konkreten Versuch. + +Bei bekannter Weitergabe werden neue importierte Ereignisse zunächst nur intern gesperrt und zur Klärung vorgelegt. Auch neu auftretende Überschneidungen mit schon vorhandenen Belegungen werden nicht ungeprüft erneut weiterverteilt. Nach Bestätigung einer eigenständigen Belegung wird diese regulär exportiert; nach Zuordnung wird nur die führende Belegung ausgegeben. Das begrenzt die Vermehrung von Ereignissen mit umgeschriebenen UIDs ohne automatische Datumszusammenführung. + +Eindeutig eigene UIDs werden weiterhin herausgefiltert. Importkanal und bekannter Ursprung bleiben Exportausschlüsse. Eine bestätigte Zuordnung ist eine fachliche Entscheidung über die führende Quelle; sie ersetzt keine laufende unabhängige Echtheitsprüfung des Portals. + +## Intervalle und Ostseeklar + +Das erwartete externe Abrufintervall ist je Kanal frei konfigurierbar. Die von Lars genannten Erfahrungswerte **FeWo-direkt ungefähr 30 Minuten** und **Ostseeklar ungefähr 24 Stunden** sind Annahmen, keine verifizierte Zusage des Portals. Sie verändern den eigenen Aufgabenplan mit fünfminütigem Import nicht. + +Ein Feedabruf wird mit unbekanntem Client protokolliert und beweist keine Verarbeitung. Das separate Feld **„Tatsächliche Übernahme im Portal zuletzt persönlich geprüft“** wird ausschließlich nach Sichtkontrolle manuell gepflegt. + +**Offene Ostseeklar-Frage:** Ersetzt der automatische iCal-Abgleich die zusätzliche Bestätigung, dass der Kalender aktuell gepflegt wurde? Dies wurde nicht geprüft. Das Feld **„Zusätzliche Anforderungen dieses Portals“** kann die Antwort und eine nötige wiederkehrende Pflegehandlung aufnehmen. Die Frage blockiert die generische Verbindung nicht. + +## Verifikation und praktische Grenzen + +Lokale Gesamtabnahme: **359 Feature-Tests / 1701 Assertions erfolgreich**, Pint erfolgreich. Zwölf zusätzliche MVP-Fälle prüfen unter anderem automatische Links beliebig benannter Portale, Zuordnung in der Verwaltung, Rollen, getrennte UID-Identität, Echozurückhaltung, Stornierung der führenden Belegung und Wiederauftauchen derselben UID. Die bisherigen 44 iCal-Fälle bleiben enthalten. + +Vor Auslieferung wurde der vorhandene FeWo-direkt-Export auf stommer.info lesend geprüft: HTTP 200, derzeit kein Ereignis. Der Serverbestand enthält keine Sperren und nur eine abgelehnte sowie eine stornierte Buchung. Es wird kein realer Aufenthalt für Tests geändert. Der bereits eingerichtete Exportlink wird weder ersetzt noch rotiert. + +Die echten externen Importadressen sind im zu Beginn geprüften Serverbestand nicht hinterlegt. Auf Wunsch des Nutzers werden sie über die Oberfläche statt einer lokalen JSON-Datei eingerichtet. Solange sie fehlen, kann kein erfolgreicher echter FeWo-direkt-/Ostseeklar-Import oder vollständiger bidirektionaler Portaltest behauptet werden. + +Nach Bereitstellung in derselben FewoPortal-Instanz sind folgende praktischen Schritte noch auszuführen und einzeln zu dokumentieren: + +| Fall | Erforderlicher Nachweis | +|---|---| +| Reale FeWo-direkt-/Ostseeklar-Importe | Tatsächliche Importadressen, erfolgreicher Lauf, UID und Herkunft im Bestand | +| Bestandsklärung | Gemeinsam dargestellte Aufenthalte persönlich identifizieren und zuordnen | +| Reguläre Weitergabe | FeWo-direkt-Ereignis im Ostseeklar-Feed und umgekehrt; jeweils eigener Ursprung ausgeschlossen | +| Sichtbare Portalübernahme | Anzeige im echten Portal nach dessen Abruf, keine Schlussfolgerung nur aus HTTP-GET | +| Eigene Testsperre ändern/entfernen | Vorher einen konkret freien Testzeitraum über alle echten Quellen abstimmen; keine unbekannte echte Belegung beeinflussen | +| Pause und Wiederaufnahme | Gespeicherter Export bleibt erhalten; danach aktueller Stand, einschließlich tatsächlichem Portalverhalten | +| Dauerbetrieb | Zuverlässigen Scheduler einrichten oder bestehenden nachweisen; ohne ihn zunächst manuell „Jetzt abgleichen“ | + +Technische Fehlerfälle bleiben automatisiert simuliert; echte Portaladressen werden dafür nicht absichtlich beschädigt. Die vorhandenen Schutzregeln gegen beschädigte Feeds und unbestätigte Massenentfernung bleiben aktiv. Auch ein regulärer iCal-Betrieb hat externe Abrufverzögerungen und garantiert keine Echtzeitsperrung für parallele Sofortbuchungen. + +Technischer Ausgangsstand und weitere Nachweise: [iCal-Kanalkonfiguration](ical-kanalkonfiguration.md), [historischer Prüfbericht](ical-synchronisation-pruefung-2026-10-27.md), [Projektstand](../STATUS.md). Neue Umsetzung: `ResolveChannelOccupation`, `ChannelEchoBehavior`, `BlockedPeriod::occupying()`, erweiterter `SyncChannel`, `ChannelOccupationResolutionTest` und Migration `2026_10_27_170252_add_channel_occupation_resolution`. diff --git a/docs/architecture/ical-praxistest-vorbereitung-2026-10-27.md b/docs/architecture/ical-praxistest-vorbereitung-2026-10-27.md new file mode 100644 index 0000000..a19bfcb --- /dev/null +++ b/docs/architecture/ical-praxistest-vorbereitung-2026-10-27.md @@ -0,0 +1,204 @@ +# iCal-Praxistest: Export bereitgestellt, Portaltest vorbereitet + +Stand: 27.10.2026 · HTTPS-Prüfung um 08:02 Uhr, Europe/Berlin + +## Ergebnis und Exportadresse + +Der vorhandene kanalspezifische Export ist auf dem bestehenden **Testsystem unter https://stommer.info** erreichbar. Für Wohnung 1 „Ferienwohnung Stommer“ wurde Kanal 1 „FeWo-direkt“ als reiner Exportkanal angelegt. Die aktive Serverversion ist `06df80e4db377969b16e26b8403dccfaf508d8a3`, Release `20261026161129-06df80e4`. + +Die vollständige, vertrauliche Adresse zum Kopieren liegt **ausschließlich lokal** in [export-url.txt](../../storage/app/private/ical-praxistest/export-url.txt). Die Datei und sämtliche Rohkalender unter `storage/app/private/ical-praxistest/` sind durch die vorhandenen Git-Regeln ausgeschlossen und liegen außerhalb des öffentlichen Speichers. Sie sind bei einem anderen Checkout nicht automatisch vorhanden. + +Adressform ohne echten Zugangstoken: + +```text +https://stommer.info/kalender/.ics +``` + +Die URL selbst ist die Zugangsberechtigung. Im Chat und in versionierten Dateien wird der Token nicht wiedergegeben. Die vorhandene Anwendung erzeugt beim Anlegen eines Kanals einen zufälligen Token mit 48 Zeichen. Es gibt derzeit keinen eigenen Rotation-Dialog; der bestehende Token wurde weder ersetzt noch veröffentlicht. + +**Wichtig vor einer Verknüpfung:** Der Feed enthält bereits die beiden unten genannten Zeiträume. Wenn die URL im echten FeWo-direkt-Portal eingetragen wird, erhält das Portal auch diese Belegungen. Es handelt sich nicht um einen leeren Testkalender. Vor dieser Kalenderverknüpfung ist die ausdrückliche Freigabe des Nutzers erforderlich. + +## Tatsächlich vorgenommene Änderungen und Grenzen + +- Ein zuvor nicht vorhandener Kanaldatensatz für FeWo-direkt wurde angelegt und für den Export aktiviert. +- Keine Importadresse und keine Mailabsender-Zuordnung hinterlegt. +- „Zusätzlich von Hand sperren“ bleibt ausgeschaltet. Für diesen Kanal entstehen dadurch keine eigenen manuellen Sperraufgaben. +- Keine Buchung und keine Sperrzeit angelegt, geändert oder gelöscht. +- Keine Portalverknüpfung eingerichtet und kein FeWo-direkt-Export abgerufen. +- Keinen Importlauf oder Scheduler gestartet und keinen automatischen Rückimport aktiviert. +- Keine Anwendungsklasse, Serverdatei, Serverkonfiguration oder Abhängigkeit verändert; kein Deployment durchgeführt. +- Das Vergleichswerkzeug ist ausschließlich ein neues lokales Hilfsmittel. Es ist nicht in die Anwendung oder deren Import eingebunden. + +Die Produktionsumgebung von FewoPortal ist weiterhin nicht eingerichtet. Der bereitgestellte Endpunkt gehört zum bestehenden Testsystem. Das reale FeWo-direkt-Vermieterportal wurde nicht bedient. + +## HTTPS- und Inhaltsprüfung + +| Prüfung | Tatsächlich beobachtet | +|---|---| +| Externer Abruf ohne interaktive Anmeldung | HTTP 200 über HTTPS mit erfolgreicher Zertifikatsprüfung | +| Antworttyp | `text/calendar; charset=utf-8` | +| Cache-Steuerung | `max-age=0, no-cache, private` | +| Falscher Zugangstoken | HTTP 404 | +| Zwei unmittelbar aufeinanderfolgende Abrufe | Bytegleich, je 496 Bytes | +| SHA-256 beider Abrufe | `fbbf71cf9f4d05cdb475feb0f31a6bd79abfd1755c6350ccc5356a3674cc68e4` | +| Vergleich mit serverseitig aufgebautem Feed | Identischer SHA-256 | +| Strukturprüfung der abgerufenen Dateien | Zwei Ereignisse, keine gefundenen Strukturfehler oder Warnungen | +| Zusätzliche Testsperre | Nicht angelegt | + +Die Dateien verwenden CRLF-Zeilenenden, die Kalenderfelder `VERSION:2.0` und `PRODID`, eindeutige `UID`s, UTC-`DTSTAMP`s sowie ganztägige `DTSTART`-/`DTEND`-Werte mit positivem Zeitraum. Das Enddatum ist exklusiv. Die vorhandenen physischen Zeilen überschreiten die empfohlene Länge von 75 Oktetten nicht. Maßstab für diese Eigenschaften ist [RFC 5545, insbesondere Abschnitte 3.1 und 3.6.1](https://www.rfc-editor.org/rfc/rfc5545). + +Das lokale Werkzeug führt gezielte Strukturprüfungen durch; es ist kein vollständiger Validator für sämtliche Möglichkeiten von RFC 5545. Die beobachteten Ergebnisse gelten für den hier tatsächlich abgerufenen Ganztagskalender und beweisen noch keine Übernahme durch FeWo-direkt. + +## Aktuell exportierte Ereignisse + +Diese Angaben wurden in einer lesenden Datenbanktransaktion mit dem tatsächlich heruntergeladenen Feed abgeglichen: + +| UID | Interne Herkunft | Beginn einschließlich | Ende ausschließlich | Bedeutung | +|---|---|---|---|---| +| `block-1@fewo-stommer` | Bestehende manuelle Sperre, keine Kanalzuordnung | 31.10.2026 | 08.11.2026 | Nächte 31.10. bis einschließlich 07.11. gesperrt | +| `booking-2@fewo-stommer` | Bestehende bestätigte Buchung | 14.11.2026 | 17.11.2026 | Nächte 14.11. bis einschließlich 16.11. belegt | + +Es sind derzeit keine FeWo-direkt-Importsperren vorhanden. Die tatsächliche Entfernung einer solchen Sperre aus genau diesem Feed konnte deshalb am Serverbestand nicht beobachtet werden; die Regel wurde im Code und mit dem vorhandenen lokalen Feature-Test geprüft. + +Allgemein enthält der bestehende Export belegende eigene Buchungen einschließlich noch gültiger Vormerkungen sowie manuelle Sperren und Sperren anderer Kanäle. Abgelaufene Vormerkungen zählen nicht. Der berücksichtigte Zeitraum reicht derzeit vom 27.09.2026 bis zum 27.10.2028 und bewegt sich mit dem Abrufdatum weiter. + +## Tatsächlich erzeugter Eintrag ohne personenbezogene Daten oder Token + +Das folgende Ereignis stammt unverändert aus dem abgerufenen Feed. Es ist die bereits vorhandene manuelle Sperre, **keine neu angelegte Testsperre**: + +```ics +BEGIN:VEVENT +UID:block-1@fewo-stommer +DTSTAMP:20261026T065948Z +DTSTART;VALUE=DATE:20261031 +DTEND;VALUE=DATE:20261108 +SUMMARY:Belegt +TRANSP:OPAQUE +END:VEVENT +``` + +Die unveränderte Rohdatei mit den tatsächlichen CRLF-Zeilenenden liegt lokal als `storage/app/private/ical-praxistest/fewoportal-ausgang.ics` vor. Der Markdown-Codeblock ist eine lesbare Wiedergabe, kein Ersatz für die Rohdatei im technischen Vergleich. + +## UID, Quellinformationen und Rückkopplungsschutz + +| Information | Im aktuellen Export enthalten? | +|---|---| +| Stabile lokale Ereigniskennung | Ja: `booking-@fewo-stommer` beziehungsweise `block-@fewo-stommer` | +| Kennzeichnung als eigener Export über UID-Suffix | Ja: `@fewo-stommer` | +| Kalenderhersteller | Ja: `PRODID:-//Ferienwohnung Stommer//Belegung//DE` | +| Kalendername | Ja: `X-WR-CALNAME:Ferienwohnung Stommer` auf Kalenderebene | +| Konkrete ursprüngliche Portalquelle am Ereignis | Nein | +| Interne `channel_id` oder `source` am Ereignis | Nein | +| Originale externe Portal-UID | Nein; der Export verwendet die lokale Sperr-ID | +| Interner Sperrgrund oder Testmarker | Nein; `SUMMARY` ist immer `Belegt` | +| `DESCRIPTION`, `URL` oder zusätzliche `X-`-Attribute am Ereignis | Nein | +| Gastname, E-Mail oder Buchungsbetrag | Nein | + +Die lokale UID bleibt bei wiederholtem Abruf und bei einer Änderung desselben Datensatzes gleich. Ein gelöschter und neu angelegter Datensatz bekommt dagegen eine andere lokale ID und damit eine andere UID. Die Kennungen sind innerhalb dieser Installation eindeutig; eine globale Eindeutigkeit gegenüber unabhängigen Kopien der Installation wurde nicht nachgewiesen. + +**Richtung A: FewoPortal → FeWo-direkt → FewoPortal.** Der vorhandene Import verwirft UIDs mit dem eigenen Suffix. Behält FeWo-direkt die exportierte UID bei, würde dieser Filter das Ereignis erkennen. Erzeugt FeWo-direkt eine neue UID ohne Suffix, fehlt derzeit eine zusätzliche Herkunftserkennung. Ob FeWo-direkt die importierte Sperre überhaupt wieder exportiert und welche Attribute dabei erhalten bleiben, ist ausdrücklich noch offen. + +**Richtung B: FeWo-direkt → FewoPortal → FeWo-direkt.** Intern wird eine Importsperre dem Herkunftskanal zugeordnet. Der Export für genau diesen Kanal schließt sie aus; zusätzliche Sperraufgaben schließen den Herkunftskanal ebenfalls aus. Im FeWo-direkt-Portal muss später genau die bereitgestellte URL dieses Kanals verwendet werden. + +Zusätzliche Kennzeichnungen wie ein Ereignisfeld `X-FEWO-SOURCE`, eine `DESCRIPTION` oder ein eigener Herkunftsverweis wären denkbar. Ob FeWo-direkt solche Angaben erhält, ist vor dem Test unbekannt. Daher wurde keine solche Kennzeichnung hinzugefügt und das bestehende Exportformat nicht geändert. + +Codegrundlage: [ICalFeed.php](../../app/Channels/ICal/ICalFeed.php), [Channel.php](../../app/Models/Channel.php), [ChannelController.php](../../app/Http/Controllers/ChannelController.php), [SyncChannel.php](../../app/Actions/SyncChannel.php), [BlockedPeriodObserver.php](../../app/Observers/BlockedPeriodObserver.php). Weitergehende bekannte Risiken stehen im unverändert belassenen [Prüfbericht](ical-synchronisation-pruefung-2026-10-27.md). + +## Nachweise durch vorhandene Tests + +Lokal ausgeführt wurden die beiden vorhandenen Fälle in [ChannelSyncTest.php](../../tests/Feature/ChannelSyncTest.php): + +- `test_export_feed_contains_all_occupations_except_the_channels_own` +- `test_manual_portals_get_tasks_when_occupations_change_elsewhere` + +Ergebnis: **2 Tests erfolgreich, 13 Assertions**. Die Tests verwenden eine In-Memory-Testdatenbank und simulierte externe Aufrufe. Sie verändern keine Kalender auf dem Server oder bei FeWo-direkt. Sie belegen keine praktische Reaktion des Portals. + +## Vorbereitung der Testsperre + +Die vorhandene Verwaltungsfunktion lautet **Vermietung → Sperrzeiten → Zeitraum sperren**. Erfasst werden die Wohnung, „Von (erste gesperrte Nacht)“, „Bis (erster freier Tag)“ und ein Grund. Der Vorgang wird als manuelle Sperre gespeichert. + +Vor einer Anlage müssen der konkrete Zeitraum und die ausdrückliche Freigabe des Nutzers vorliegen. Direkt vor der Anlage sind die eigene aktuelle Belegung und die tatsächliche Verfügbarkeit im FeWo-direkt-Portal zu prüfen. Da der Rückimport für diesen Test nicht aktiviert wird, kann der eigene Kalender allein die externe Verfügbarkeit nicht bestätigen. + +Ein eindeutiger interner Grund kann beispielsweise `iCal-Praxistest – freigegebener Zeitraum` lauten. Dieser Grund wird nicht exportiert. Identifiziert wird das Ereignis nach der Anlage anhand seiner neuen UID, des freigegebenen Zeitraums und des Unterschieds zur vorher gesicherten Datei. Die UID wird nicht vorher geraten. + +Auch die spätere Entfernung der Testsperre benötigt eine ausdrückliche Freigabe. Vorhandene Buchungen und andere Sperren bleiben dabei unverändert. + +## Ablauf im FeWo-direkt-Portal – durch den Nutzer + +1. **Vor jeder Verknüpfung:** Die beiden bestehenden Exportereignisse oben prüfen und die Kalenderverknüpfung ausdrücklich freigeben. Den bisherigen FeWo-direkt-Export unverändert als `fewodirekt-vorher.ics` sichern, dazu Abrufzeit und sichtbaren Kalenderzustand notieren. +2. Die vertrauliche FewoPortal-URL selbst im FeWo-direkt-Vermieterportal als externen Kalender eintragen. Der Agent übernimmt diesen Schritt nicht. +3. Gewünschten Testzeitraum prüfen und die Anlage der Testsperre ausdrücklich freigeben. Erst danach die Testsperre über die vorhandene Verwaltung anlegen. +4. FewoPortal-Export erneut als `fewoportal-mit-testsperre.ics` speichern. Neue UID und exklusives Enddatum feststellen. +5. Übernahme im sichtbaren FeWo-direkt-Kalender prüfen. Den ersten beobachteten Zeitpunkt notieren; aus zwei Beobachtungen ergibt sich nur ein Zeitfenster, keine garantierte Synchronisationsdauer. +6. Nach sichtbarer Übernahme den FeWo-direkt-Export als `fewodirekt-nach-import.ics` sichern. Sowohl vorher/nachher als auch den FewoPortal-Export gegen den neuen Portalexport vergleichen. +7. Ergebnisse gemeinsam auswerten. Keine zurückgelieferte Datei durch einen echten Importjob verarbeiten. +8. Nach gesonderter Freigabe ausschließlich die angelegte Testsperre in FewoPortal löschen. FewoPortal-Export als `fewoportal-nach-loeschung.ics` sichern. +9. Den FeWo-direkt-Kalender beobachten. Erst sichtbare Freigabe im Portal bestätigt die Freigabe dort. Anschließend `fewodirekt-nach-loeschung.ics` sichern und vergleichen. +10. Bei einem verwaisten Eintrag oder unerwarteten Ereignissen anhalten und die Dateien auswerten. Keine zusätzliche automatische Bereinigung oder Änderung anderer Kalender vornehmen. Eine Entfernung der Kalenderverknüpfung wäre ebenfalls eine eigene freizugebende Änderung. + +Die Dateinamen bezeichnen unterschiedliche Beobachtungspunkte. Bestehende Rohdateien nicht überschreiben; bei weiteren Abrufen einen Zeitstempel ergänzen. Rohkalender und Detailberichte können bei späteren Portaldateien personenbezogene Daten oder URLs enthalten und bleiben deshalb in der privaten lokalen Ablage. + +## Vorbereitete Vergleichsmethode + +Das neue lokale Werkzeug [scripts/compare-ical.py](../../scripts/compare-ical.py) benötigt nur die Python-Standardbibliothek. Es liest lokale Dateien und greift weder auf Netzwerk, Datenbank noch Anwendung zu. Die Eingabedateien werden nicht verändert; eine bestehende Berichtsdatei wird nicht überschrieben. + +Ausführung im Projektverzeichnis mit den privat gespeicherten Dateien: + +```powershell +python scripts/compare-ical.py storage/app/private/ical-praxistest/fewodirekt-vorher.ics storage/app/private/ical-praxistest/fewodirekt-nach-import.ics --own-uid-suffix '@fewo-stommer' --output storage/app/private/ical-praxistest/vergleich-portal-import.json +``` + +Zusätzlich die FewoPortal-Datei mit der enthaltenen Testsperre gegen den Portalexport prüfen: + +```powershell +python scripts/compare-ical.py storage/app/private/ical-praxistest/fewoportal-mit-testsperre.ics storage/app/private/ical-praxistest/fewodirekt-nach-import.ics --own-uid-suffix '@fewo-stommer' --output storage/app/private/ical-praxistest/vergleich-quelle-portal.json +``` + +Nach der freigegebenen Löschung: + +```powershell +python scripts/compare-ical.py storage/app/private/ical-praxistest/fewodirekt-nach-import.ics storage/app/private/ical-praxistest/fewodirekt-nach-loeschung.ics --own-uid-suffix '@fewo-stommer' --output storage/app/private/ical-praxistest/vergleich-portal-loeschung.json +``` + +Eine einzelne Datei kann ohne zweiten Dateinamen inspiziert werden. Für weitere Vergleiche neue Namen für die JSON-Berichte wählen. + +Das Werkzeug: + +- entfaltet iCal-Zeilen vor der UTF-8-Auswertung; +- ordnet Ereignisse anhand `UID` und gegebenenfalls `RECURRENCE-ID` zu; +- vergleicht sämtliche erfassten Ereignisattribute einschließlich Parametern, `SUMMARY`, `DESCRIPTION`, `DTSTAMP`, `STATUS` und `X-`-Attributen; +- zeigt hinzugekommene, entfernte, geänderte und unveränderte Ereignisse getrennt; +- weist doppelte Identitäten als mehrdeutig aus, statt sie willkürlich zusammenzuführen; +- markiert gleiche Zeiträume mit unterschiedlicher UID nur als Kandidaten, nicht als Beweis derselben Herkunft; +- nennt ausdrücklich mit `STATUS:CANCELLED` versehene Ereignisse separat; +- zeigt, welche UIDs zum angegebenen eigenen Suffix passen würden; +- bricht bei abgeschnittenen oder strukturell beschädigten Kalendern ab; +- gibt auf der Konsole nur eine Zusammenfassung aus und legt die vollständigen Attributwerte nur bei `--output` in der benannten lokalen Datei ab. + +Serien werden nicht expandiert und Zeitzonen nicht auf eine gemeinsame Zeit umgerechnet. Die Attribute bleiben im Bericht erhalten; ein Unterschied ihrer Darstellung wird nicht stillschweigend als semantische Gleichheit gewertet. Ein gleicher Zeitraum allein kann insbesondere bei mehreren Ereignissen mehrdeutig sein. Die Suffixanalyse modelliert nur den vorhandenen UID-Filter, keinen vollständigen Importlauf. + +**Ein fehlendes Ereignis ist kein aktives Stornoereignis und kein Nachweis, dass der Termin im Portal wieder buchbar ist.** Der Bericht trennt das Verschwinden eines Ereignisses von ausdrücklich enthaltenem `STATUS:CANCELLED`. Der sichtbare Portalzustand und seine Beobachtungszeit werden separat protokolliert. + +## Bereits geprüfte Vergleichsfälle + +Die Vergleichsfunktionen wurden mit synthetischen Daten für UID-Erhaltung, neue UID bei gleichem Zeitraum, Attributänderungen, `DESCRIPTION`/`X-`-Attribute, Entfernung gegenüber explizitem Storno, mehrdeutige Identitäten, gefaltetes UTF-8, quoted Parameter, ungültige Daten und beschädigte Kalender geprüft. + +Der Vergleich der beiden echten FewoPortal-Abrufe ergab: + +```json +{ + "before_events": 2, + "validation_errors": 0, + "warnings": 0, + "after_events": 2, + "unchanged_events": 2, + "changed_events": 0, + "removed_events": 0, + "added_events": 0, + "ambiguous_identities": 0, + "same_interval_new_uid_candidates": 0, + "explicit_cancellations_after": 0 +} +``` + +Die Rohdateien, HTTP-Prüfwerte und der Detailvergleich liegen lokal unter `storage/app/private/ical-praxistest/`. Es gibt noch keinen FeWo-direkt-Vorher-/Nachher-Vergleich und keinen Befund zum tatsächlichen Rückexport importierter Termine. diff --git a/docs/architecture/ical-synchronisation-pruefung-2026-10-27.md b/docs/architecture/ical-synchronisation-pruefung-2026-10-27.md new file mode 100644 index 0000000..c4c127f --- /dev/null +++ b/docs/architecture/ical-synchronisation-pruefung-2026-10-27.md @@ -0,0 +1,184 @@ +**Der direkte FeWo-direkt-Fall ist korrekt abgesichert:** Eine als Sperrzeit mit FeWo-direkt als Herkunftskanal importierte Sofortbuchung wird im Feed für genau diesen Kanal ausgeschlossen. Auch eine manuelle Sperraufgabe wird nicht an den Herkunftskanal zurückgegeben. + +**Eine umfassende Rückkopplungs- und Dublettensicherheit besteht dennoch nicht.** Risiken liegen besonders bei veränderter Herkunft, der Mail/iCal-Zusammenführung, unvollständigen Kalenderantworten und den Sperraufgaben bei Terminänderungen. + +Prüfstand: lokaler Commit `6fe5bbc`, 27.10.2026. Keine Dateien, Anwendungsdaten, Konfigurationen oder Kalender verändert. Keine Portal-, Postfach- oder Datenbankzugriffe ausgeführt. + +**Dokumentation, Implementierung und Verifikation** + +| Ebene | Feststellung | +|---|---| +| Dokumentiert | Kanalspezifische Feeds ohne eigene Portalbelegungen; Kalenderabgleich alle fünf Minuten; Mail-Schnellweg mit späterer Kalenderbestätigung. Siehe [PORTALE.md:100](C:/Dev/fewo-stommer.de/docs/PORTALE.md:100). | +| Implementiert | Herkunftskanal, Exportausschluss und zusätzlicher UID-Echofilter sind vorhanden. Änderungen und Löschungen werden anhand der UID verarbeitet. | +| Vorhandene Testnachweise | Feature-Tests mit synthetischen Kalendern und simuliertem HTTP/Mailversand. Laut Projektstand war die Gesamtsuite erfolgreich; in dieser Prüfung nicht erneut ausgeführt. | +| Hier praktisch geprüft | Ausschließlich speicherbasierte Parserproben und eine isolierte Probe des installierten Laravel-After-Commit-Verhaltens. | +| Nicht praktisch verifiziert | Tatsächliche Portalzuordnungen, eingetragene Exportadressen, echte FeWo-direkt-Ereignisse, UID-Erhaltung durch andere Portale und deren Löschverhalten. Laut [Betriebsdokumentation](C:/Dev/fewo-stommer.de/docs/BETRIEB.md:15) sind Postfachabruf und regelmäßiger Hintergrundbetrieb noch nicht vollständig eingerichtet. | + +**1. Import, Herkunft und Export je Kanal** + +Es existiert ein generischer iCal-Connector, keine besondere FeWo-direkt-Importlogik. Importadresse und Exporttoken gehören zum jeweiligen Kanaldatensatz. Der reguläre Import berücksichtigt aktive, freigeschaltete Kanäle mit Importadresse: [SyncChannels.php:29](C:/Dev/fewo-stommer.de/app/Console/Commands/SyncChannels.php:29). + +Die Herkunft wird folgendermaßen geführt: + +| Eingang | Kennzeichnung | +|---|---| +| iCal | `channel_id` des abrufenden Kanals, `source = channel`, ursprüngliche `external_uid` | +| Portal-Mail | `channel_id` des erkannten Kanals, `source = email`, zunächst `external_uid = email:` | +| Manuelle Sperre | `source = manual`; ohne Kanalzuordnung gilt sie als eigene Sperre | + +Beim iCal-Import entstehen **Sperrzeiten, keine vollständigen Buchungen**. Der Portalname wird als Grund gespeichert; der möglicherweise personenbezogene `SUMMARY` wird nicht übernommen. Siehe [SyncChannel.php:64](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:64) und [ProcessPortalMail.php:136](C:/Dev/fewo-stommer.de/app/Actions/ProcessPortalMail.php:136). + +Für eine FeWo-direkt-Sofortbuchung mit Herkunftskanal **A** ergibt sich: + +| Ziel | Verhalten im Code | +|---|---| +| Eigene Verfügbarkeitsprüfung | Zeitraum ist gesperrt | +| Exportfeed für A | Sperre ausgeschlossen | +| Exportfeed für anderen Kanal B | Sperre enthalten | +| Manuelle Sperraufgabe für A | ausgeschlossen | +| Manuelle Sperraufgabe für B | entsteht, sofern B entsprechend eingerichtet ist | + +Der Export filtert ausdrücklich nach `channel_id`, unabhängig davon, ob die Sperre aus Mail oder iCal stammt: [ICalFeed.php:31](C:/Dev/fewo-stommer.de/app/Channels/ICal/ICalFeed.php:31). Der Observer übergibt dieselbe Herkunft als Ausschluss an die Aufgabenanlage: [BlockedPeriodObserver.php:43](C:/Dev/fewo-stommer.de/app/Observers/BlockedPeriodObserver.php:43), [CreateChannelTasks.php:33](C:/Dev/fewo-stommer.de/app/Actions/CreateChannelTasks.php:33). + +Der Kalender wird zum Abruf bereitgestellt; ein Abruf durch FeWo-direkt ist dadurch noch nicht nachgewiesen. + +**2. Grenzen des Rückkopplungsschutzes** + +Zusätzlich erzeugt der Export UIDs wie `block-123@fewo-stommer`. Beim Import werden Ereignisse mit diesem Suffix verworfen: [ICalFeed.php:37](C:/Dev/fewo-stommer.de/app/Channels/ICal/ICalFeed.php:37), [SyncChannel.php:43](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:43). + +Dieser zweite Schutz funktioniert nur bei erhaltenem Suffix: + +- A-Belegung wird intern importiert und an B exportiert. +- B liefert dieselbe Belegung mit **neu erzeugter UID ohne Suffix** zurück. +- Sie wird als neue B-Sperre importiert. +- Diese B-Sperre erscheint anschließend im Feed für A. + +**Eine ursprüngliche Herkunft über mehrere Portale hinweg wird nicht gespeichert.** Ob ein tatsächlich genutztes Portal UIDs verändert, ist nicht praktisch geprüft. + +Außerdem gilt der Ausschluss für die **konkrete Kanal-ID**, nicht für den Namen „FeWo-direkt“. Ein zweiter Kanaldatensatz desselben Portals oder eine im Portal vertauschte Feedadresse kann den Schutz umgehen. + +Eine weitere Grenze: Wird ein Portalaufenthalt zusätzlich als normale `Booking` erfasst, exportiert der Feed diese Buchung ohne kanalbezogenen Herkunftsausschluss: [ICalFeed.php:26](C:/Dev/fewo-stommer.de/app/Channels/ICal/ICalFeed.php:26). Auch der Buchungsobserver reicht keinen Herkunftskanal zum Ausschluss weiter: [BookingObserver.php:56](C:/Dev/fewo-stommer.de/app/Observers/BookingObserver.php:56). + +**3. Änderungen und Stornierungen** + +Für vorhandene iCal-Sperren gilt: + +- Gleiche Kanal-ID und UID, unveränderte Daten: keine Änderung. +- Gleiche UID, andere Daten: vorhandene Sperre aktualisieren. +- Zukünftige Sperre fehlt im nächsten erfolgreich verarbeiteten Feed: löschen. +- `STATUS:CANCELLED`: Parser überspringt das Ereignis; dadurch wird eine zuvor importierte zukünftige Sperre anschließend als fehlend entfernt. +- Vergangene Sperren werden bei dieser Bereinigung behalten. + +Code: [SyncChannel.php:52](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:52), [SyncChannel.php:100](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:100), [ICalParser.php:63](C:/Dev/fewo-stommer.de/app/Channels/ICal/ICalParser.php:63). + +HTTP-Fehler oder eine Antwort ohne Kalenderkennung führen zum Fehlerpfad, bevor Sperren abgeglichen werden. + +**Hohes Risiko: unvollständige Kalender werden dagegen als gültiger Bestand behandelt.** Praktisch beobachtet: + +| Parserprobe | Ergebnis | +|---|---| +| Gültiger Kalender mit einem Ereignis | ein Zeitraum | +| Nur `BEGIN:VCALENDAR` | null Zeiträume, keine Ausnahme | +| Ein vollständiges und ein abgeschnittenes Ereignis | nur das vollständige Ereignis, keine Ausnahme | +| HTML statt Kalender | Ausnahme | + +Der Parser verlangt keine vollständige Kalenderstruktur: [ICalParser.php:22](C:/Dev/fewo-stommer.de/app/Channels/ICal/ICalParser.php:22). Zusammen mit der Löschung fehlender Ereignisse bedeutet das: **Eine unvollständige erfolgreiche HTTP-Antwort kann bestehende Sperren entfernen und anschließend als erfolgreicher Abgleich protokolliert werden.** Diese Löschfolge ist aus dem Code abgeleitet, nicht an einer Datenbank ausgeführt. + +**4. Zusammenführung von Mail-Sperren und iCal** + +Die implementierte Logik ist eingeschränkter als die allgemeine Dokumentationsaussage „abweichende Daten ersetzen die Mail-Sperre“: + +| Fall | Tatsächliches Verhalten | +|---|---| +| Gleicher Kanal und exakt gleiche Termine | Mail-Sperre wird auf `source = channel` und iCal-UID umgestellt; dieselbe Sperr-ID bleibt erhalten | +| Abweichende, überlappende Termine | iCal-Sperre wird angelegt/aktualisiert; überlappende Mail-Sperren desselben Kanals werden gelöscht | +| Vollständig verschobener, nicht überlappender Termin | Keine Zusammenführung; alte Mail-Sperre bleibt zusätzlich bestehen | +| Kalender kennt die Mail-Buchung noch nicht | Mail-Sperre bleibt absichtlich bestehen | + +Code: [SyncChannel.php:73](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:73), [SyncChannel.php:92](C:/Dev/fewo-stommer.de/app/Actions/SyncChannel.php:92). + +**Risiko:** Beim Ersetzen wird keine Buchungsreferenz mit der iCal-UID abgeglichen. Überschneidung allein gilt als Zuordnung. Dadurch können andere Mail-Sperren fälschlich entfernt werden; vollständig verschobene Buchungen können dagegen doppelt gesperrt bleiben. + +Die Mail-Stornierung löscht ausschließlich `source = email`. Nach erfolgreicher iCal-Übernahme kann sie die Sperre nicht mehr unmittelbar aufheben; sie meldet Prüfbedarf und wartet auf den Kalenderabgleich: [ProcessPortalMail.php:155](C:/Dev/fewo-stommer.de/app/Actions/ProcessPortalMail.php:155). + +Umgekehrt verschwinden nie bestätigte Mail-Sperren nicht durch bloßes Fehlen im Kalender. Ohne passende Stornomail oder weitere Bearbeitung können sie bestehen bleiben. + +**5. Doppelsperren und manuelle Portalpflege** + +Hier bestehen zusätzliche Risiken: + +- **Doppelte UID im selben Feed:** Der Parser liefert beide Ereignisse zurück – praktisch bestätigt. Der Import verwendet einen einmalig eingelesenen Bestand und ergänzt diesen während der Schleife nicht. Neue doppelte UIDs können deshalb mehrfach angelegt werden. Ein Unique-Constraint verhindert das nicht; vorhanden ist nur ein Index: [Migration:16](C:/Dev/fewo-stommer.de/database/migrations/2026_10_22_110346_add_channel_and_referral_fields.php:16). +- **Parallele Läufe:** Keine kanalbezogene Sperre innerhalb von `SyncChannel`. Der Scheduler besitzt Überlappungsschutz; manuelle Aufrufe können daneben stattfinden. +- **Gleichkanalige Überschneidungen:** Die Konflikterkennung ignoriert sie ausdrücklich. Damit meldet sie auch entsprechende Dubletten nicht: [ConflictDetector.php:26](C:/Dev/fewo-stommer.de/app/Channels/ConflictDetector.php:26). +- **Belegung versus Export:** Die Verfügbarkeitsprüfung behandelt Nächte als Menge; doppelte Datensätze verdoppeln dort keine Nächte. Der Export erzeugt hingegen ein Ereignis pro Sperrdatensatz: [AvailabilityChecker.php:39](C:/Dev/fewo-stommer.de/app/Availability/AvailabilityChecker.php:39). + +**Hohes Risiko bei Terminänderungen:** Der Sperrzeit-Observer läuft nach Commit und liest die alten Termine mit `getOriginal()`: [BlockedPeriodObserver.php:24](C:/Dev/fewo-stommer.de/app/Observers/BlockedPeriodObserver.php:24). + +Das installierte Laravel reicht dasselbe Modellobjekt verzögert weiter und synchronisiert zuvor dessen Originalwerte: [Dispatcher.php:620](C:/Dev/fewo-stommer.de/vendor/laravel/framework/src/Illuminate/Events/Dispatcher.php:620), [Model.php:1510](C:/Dev/fewo-stommer.de/vendor/laravel/framework/src/Illuminate/Database/Eloquent/Model.php:1510). + +Die speicherbasierte Probe ergab: + +```text +Vor verzögertem Aufruf: original = 2026-11-07 +Im After-Commit-Listener: + wasChanged = true + original = 2026-11-14 + current = 2026-11-14 +``` + +Damit kann die Entsperraufgabe den **neuen statt des alten Zeitraums** betreffen. Der vollständige Anwendungspfad wurde nicht ausgeführt. + +Beim Ersetzen einer überlappenden Mail-Sperre besteht außerdem die Aufgabenfolge „neuen Zeitraum sperren, alten Zeitraum entsperren“. Eine Prüfung, welche Nächte weiterhin durch andere Sperren belegt sind, erfolgt in der Aufgabenanlage nicht. Eine nachgelagerte Automatisierung könnte dadurch weiterhin belegte Nächte freigeben. + +**6. Herkunftszuordnung über E-Mail** + +Die Kanalauswahl nimmt den ersten aktiven Kanal mit passendem Absenderfragment. Inserats- oder Wohnungskennung werden dabei nicht ausgewertet: [ProcessPortalMail.php:92](C:/Dev/fewo-stommer.de/app/Actions/ProcessPortalMail.php:92). + +Bei mehreren Wohnungen desselben Mandanten mit FeWo-direkt-Kanälen und identischen Absenderregeln kann eine Mail deshalb der falschen Wohnung zugeordnet werden. Der iCal-Import hat dieses spezielle Problem nicht, weil er bereits einen bestimmten Kanal abruft. + +**Vorhandene Tests und ihre Grenzen** + +| Abdeckung | Codeverweis | +|---|---| +| Datumswerte, Uhrzeiten, gefaltete Zeilen, stornierte Ereignisse | [ChannelSyncTest.php:60](C:/Dev/fewo-stommer.de/tests/Feature/ChannelSyncTest.php:60) | +| Hinzufügen, Ändern, Entfernen und eigenes UID-Suffix ignorieren | [ChannelSyncTest.php:88](C:/Dev/fewo-stommer.de/tests/Feature/ChannelSyncTest.php:88) | +| Eigene Portalbelegung im Export ausschließen | [ChannelSyncTest.php:137](C:/Dev/fewo-stommer.de/tests/Feature/ChannelSyncTest.php:137) | +| Herkunftskanal von manuellen Aufgaben ausschließen | [ChannelSyncTest.php:156](C:/Dev/fewo-stommer.de/tests/Feature/ChannelSyncTest.php:156) | +| Mail sofort sperren; wiederholte Nachricht erkennen | [PortalMailTest.php:90](C:/Dev/fewo-stommer.de/tests/Feature/PortalMailTest.php:90) | +| Exakte Mail/iCal-Zusammenführung ohne zusätzliche Aufgaben | [PortalMailTest.php:116](C:/Dev/fewo-stommer.de/tests/Feature/PortalMailTest.php:116) | +| Überlappend geänderte Termine ersetzen Mail-Sperre | [PortalMailTest.php:130](C:/Dev/fewo-stommer.de/tests/Feature/PortalMailTest.php:130) | +| Mail-Sperre überlebt leeren Feed; Mail-Storno gibt sie frei | [PortalMailTest.php:140](C:/Dev/fewo-stommer.de/tests/Feature/PortalMailTest.php:140) | +| Mandantentrennung und Dienstsperre für Feeds | [TenantScheduleTest.php:123](C:/Dev/fewo-stommer.de/tests/Feature/TenantScheduleTest.php:123), [TenantServiceGateTest.php:27](C:/Dev/fewo-stommer.de/tests/Feature/TenantServiceGateTest.php:27) | + +Der Exporttest legt Sperren direkt an. Er prüft **nicht die komplette Kette** FeWo-Sofortbuchungsmail → iCal-Übernahme → beide Exportfeeds → Storno. Die Änderungstests prüfen außerdem nicht die korrekten alten/neuen Zeiträume aller manuellen Aufgaben. + +Weitere Parsergrenzen aus den Speicherproben: Wiederholungsregeln werden nicht expandiert; `20261131` wird zu `2026-12-01` normalisiert statt zurückgewiesen. + +**Reproduzierbarer Testplan – nicht ausgeführt** + +Für die zustandsändernden Fälle ausschließlich eine separate Wegwerf-Testumgebung verwenden: leere In-Memory-Datenbank, simuliertes HTTP/Mail, keine externen Netzwerkzugriffe oder echten Tokens. Keine Kopie produktiver Daten erforderlich. + +Ausgangslage je Fall neu herstellen: Zeit **01.11.2026**, eine Wohnung, Kanäle **A = FeWo-direkt** und **B = anderes Portal**, beide mit manueller Sperrpflege. Kalenderereignis **U1 = 07.–10.11.2026**. + +| Fall | Schritte und zu prüfendes Ergebnis | +|---|---| +| T1 – Zentraler FeWo-Fall | U1 über A importieren. Genau eine A-Sperre; im A-Feed nicht enthalten, im B-Feed enthalten; keine A-Sperraufgabe. | +| T2 – Wiederholung | Identischen A-Feed zweimal importieren. Sperr-ID und Anzahl unverändert; keine zusätzlichen Aufgaben. | +| T3 – Unverändertes Echo | B liefert die exportierte UID mit `@fewo-stommer` zurück. Keine neue B-Sperre und kein Rückexport an A. | +| T4 – Veränderte Echo-UID | B liefert denselben Zeitraum mit neuer UID ohne Suffix. Prüfen, dass aktuell eine B-Sperre und damit ein Rückexport an A entsteht. | +| T5 – Mail vor Kalender | A-Mail mit Referenz `HA-TEST01` für U1 verarbeiten, danach U1 importieren. Dieselbe Sperr-ID, Quelle `channel`, keine zusätzlichen Aufgaben; beide Feeds prüfen. | +| T6 – Terminänderungen | U1 bei gleicher UID zunächst verlängern, dann vollständig auf 14.–17.11. verschieben. Datenbestand sowie Entsperrung des alten und Sperrung des neuen Zeitraums prüfen. Mail-Vorlauf gesondert wiederholen. | +| T7 – Unsichere Zusammenführung | Zwei unterschiedliche Mail-Sperren anlegen; ein iCal-Ereignis über beide hinweg liefern. Prüfen, welche Mail-Sperren ohne Referenznachweis gelöscht werden. | +| T8 – Storno | Getrennt testen: Mail-Storno vor Übernahme; Mail-Storno nach Übernahme; U1 fehlt; U1 trägt `STATUS:CANCELLED`. Belegung, Feed und Aufgaben jeweils prüfen. | +| T9 – Fehlerantworten | Nach bestehendem U1 HTTP 500, HTML, nur `BEGIN:VCALENDAR` und abgeschnittenen Kalender liefern. Sperrerhalt und Erfolgsmeldung vergleichen. | +| T10 – Dubletten | U1 zweimal im selben Feed liefern; anschließend erneut synchronisieren. Anzahl, UIDs, Konfliktmeldungen und Exportereignisse prüfen. Parallelaufrufe separat testen. | +| T11 – Überlappende Sperraufgaben | Mail U1, danach iCal 07.–11.11. Aufgaben für B in Ausführungsreihenfolge auswerten: Bleiben 07.–10.11. trotz nachfolgender Entsperraufgabe geschlossen? | +| T12 – Mehrere Wohnungen | Zweite Wohnung mit eigenem A-Kanal und gleichen Mailabsendern anlegen. Nachweisen, welcher Wohnung eine Mail tatsächlich zugeordnet wird. | + +Vorhandene Tests lassen sich später dort ohne PHPUnit-Ergebnisdatei ausführen: + +```powershell +php vendor/bin/phpunit --do-not-cache-result --filter='ChannelSyncTest|PortalMailTest|TenantScheduleTest|TenantServiceGateTest' +``` + +**Bewertung:** Der direkte Herkunftsausschluss für FeWo-direkt ist nachvollziehbar implementiert und durch Teiltests abgedeckt. Eine praktische Freigabe der gesamten Synchronisationskette lässt sich daraus noch nicht ableiten. Vorrangige Prüfpunkte sind der Umgang mit unvollständigen Feeds, die Terminänderungsaufgaben und die nur heuristische Zuordnung zwischen Mail und iCal. diff --git a/tests/Feature/ChannelOccupationResolutionTest.php b/tests/Feature/ChannelOccupationResolutionTest.php new file mode 100644 index 0000000..39a000f --- /dev/null +++ b/tests/Feature/ChannelOccupationResolutionTest.php @@ -0,0 +1,280 @@ +property(); + $a = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/a.ics']]); + $b = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/b.ics']]); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/a.ics' => Http::response(self::feed('uid-a')), 'https://portal.example/b.ics' => Http::response(self::feed('uid-b'))]); + Mail::fake(); + + app(SyncChannel::class)->handle($a); + app(SyncChannel::class)->handle($b); + app(SyncChannel::class)->handle($b); + + $this->assertSame(2, $property->blockedPeriods()->count()); + $this->assertSame([false, false, true], [$b->blockedPeriods()->sole()->is_representation, $b->blockedPeriods()->sole()->export_approved, $b->blockedPeriods()->sole()->needs_review]); + $this->assertStringNotContainsString('block-'.$b->blockedPeriods()->sole()->id.'@', app(ICalFeed::class)->build($a)); + Http::assertSentCount(3); + } + + public function test_reexporting_channel_holds_new_events_internally_until_individually_confirmed(): void + { + $property = $this->property(); + $a = Channel::factory()->for($property)->create(['echo_behavior' => ChannelEchoBehavior::Reexports, 'settings' => ['import_url' => 'https://portal.example/a.ics']]); + $b = Channel::factory()->for($property)->create(); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/a.ics' => Http::response(self::feed('external'))]); + Mail::fake(); + app(SyncChannel::class)->handle($a); + $block = $a->blockedPeriods()->sole(); + $this->assertFalse($block->export_approved); + $this->assertFalse($this->available($property)); + $this->assertStringNotContainsString('block-'.$block->id.'@', app(ICalFeed::class)->build($b)); + + app(ResolveChannelOccupation::class)->handle($block, 'independent', originId: $a->id); + + $this->assertStringContainsString('block-'.$block->id.'@', app(ICalFeed::class)->build($b)); + $this->assertStringNotContainsString('block-'.$block->id.'@', app(ICalFeed::class)->build($a)); + $this->assertFalse($block->fresh()->needs_review); + Http::assertSentCount(1); + } + + public function test_linked_calendar_representation_never_keeps_a_cancelled_primary_block_occupied(): void + { + $property = $this->property(); + $a = Channel::factory()->for($property)->create(); + $b = Channel::factory()->for($property)->create(); + $primary = $this->block($property, $a, 'primary'); + $copy = $this->block($property, $b, 'copy'); + app(ResolveChannelOccupation::class)->handle($copy, 'block', $primary->id, $a->id); + $this->assertFalse($this->available($property)); + $primary->delete(); + + $this->assertTrue($this->available($property)); + $this->assertTrue($copy->fresh()->is_representation); + $this->assertSame($primary->id, $copy->fresh()->canonical_block_id); + $this->assertSoftDeleted($primary); + $this->assertStringNotContainsString('BEGIN:VEVENT', app(ICalFeed::class)->build($a)); + } + + public function test_representation_of_local_booking_follows_its_cancellation(): void + { + $property = $this->property(); + $channel = Channel::factory()->for($property)->create(); + $booking = Booking::factory()->for($property)->create(['status' => BookingStatus::Confirmed, 'arrival' => '2027-05-23', 'departure' => '2027-05-30']); + $copy = $this->block($property, $channel, 'copy'); + app(ResolveChannelOccupation::class)->handle($copy, 'booking', $booking->id); + + $booking->update(['status' => BookingStatus::Cancelled]); + + $this->assertTrue($this->available($property)); + $this->assertSame($booking->id, $copy->fresh()->linked_booking_id); + $this->assertStringNotContainsString('BEGIN:VEVENT', app(ICalFeed::class)->build($channel)); + } + + public function test_primary_uid_reappearing_restores_same_local_identity_and_keeps_alias_assignment(): void + { + $property = $this->property(); + $a = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/a.ics']]); + $b = Channel::factory()->for($property)->create(); + $primary = $this->block($property, $a, 'primary'); + $copy = $this->block($property, $b, 'copy'); + app(ResolveChannelOccupation::class)->handle($copy, 'block', $primary->id); + $primary->delete(); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/a.ics' => Http::response(self::feed('primary'))]); + Mail::fake(); + + $result = app(SyncChannel::class)->handle($a); + + $this->assertTrue($result->successful); + $this->assertSame($primary->id, $a->blockedPeriods()->sole()->id); + $this->assertSame($primary->id, $copy->fresh()->canonical_block_id); + $this->assertFalse($this->available($property)); + Http::assertSentCount(1); + } + + public function test_linked_representation_changed_by_portal_is_flagged_without_reopening_its_old_period(): void + { + $property = $this->property(); + $a = Channel::factory()->for($property)->create(); + $b = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/b.ics']]); + $primary = $this->block($property, $a, 'primary'); + $copy = $this->block($property, $b, 'copy'); + app(ResolveChannelOccupation::class)->handle($copy, 'block', $primary->id); + $primary->update(['starts_on' => '2027-06-01', 'ends_on' => '2027-06-08']); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/b.ics' => Http::response(self::feed('copy'))]); + Mail::fake(); + + app(SyncChannel::class)->handle($b); + + $this->assertTrue($copy->fresh()->needs_review); + $this->assertTrue($this->available($property)); + $this->assertStringNotContainsString('20270523', app(ICalFeed::class)->build($a)); + Http::assertSentCount(1); + } + + public function test_mapping_rejects_different_dates_or_a_different_property_without_changing_inventory(): void + { + $property = $this->property(); + $channel = Channel::factory()->for($property)->create(); + $block = $this->block($property, $channel, 'copy'); + $other = BlockedPeriod::factory()->create(['starts_on' => '2027-05-23', 'ends_on' => '2027-05-30']); + $wrongDates = BlockedPeriod::factory()->for($property)->create(['starts_on' => '2027-05-23', 'ends_on' => '2027-05-31']); + + foreach ([$other, $wrongDates, $block] as $invalidTarget) { + try { + app(ResolveChannelOccupation::class)->handle($block, 'block', $invalidTarget->id); + $this->fail('An unverified target must not be accepted.'); + } catch (ValidationException $exception) { + $this->assertArrayHasKey('target_id', $exception->errors()); + } + } + $this->assertFalse($block->fresh()->is_representation); + $this->assertSame(3, BlockedPeriod::count()); + } + + public function test_alias_chains_are_rejected_and_an_assignment_can_be_explicitly_reversed(): void + { + $property = $this->property(); + $channel = Channel::factory()->for($property)->create(); + $a = $this->block($property, $channel, 'a'); + $b = $this->block($property, $channel, 'b'); + $c = $this->block($property, $channel, 'c'); + app(ResolveChannelOccupation::class)->handle($b, 'block', $a->id); + try { + app(ResolveChannelOccupation::class)->handle($a, 'block', $c->id); + $this->fail('A primary with linked representations cannot become a representation itself.'); + } catch (ValidationException $exception) { + $this->assertArrayHasKey('target_id', $exception->errors()); + } + + app(ResolveChannelOccupation::class)->handle($b, 'independent'); + + $this->assertNull($b->fresh()->canonical_block_id); + $this->assertFalse($b->fresh()->is_representation); + $this->assertTrue($b->fresh()->export_approved); + } + + public function test_same_uid_in_different_channels_is_independently_identified(): void + { + $property = $this->property(); + $a = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/a.ics']]); + $b = Channel::factory()->for($property)->create(['settings' => ['import_url' => 'https://portal.example/b.ics']]); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/a.ics' => Http::response(self::feed('same')), 'https://portal.example/b.ics' => Http::response(self::feed('same', '20270601', '20270608'))]); + Mail::fake(); + + app(SyncChannel::class)->handle($a); + app(SyncChannel::class)->handle($b); + + $this->assertNotSame($a->blockedPeriods()->sole()->id, $b->blockedPeriods()->sole()->id); + $this->assertSame('2027-05-23', $a->blockedPeriods()->sole()->starts_on->toDateString()); + $this->assertSame('2027-06-01', $b->blockedPeriods()->sole()->starts_on->toDateString()); + Http::assertSentCount(2); + } + + public function test_landlord_can_resolve_a_duplicate_through_the_existing_admin(): void + { + $property = $this->property(); + $channel = Channel::factory()->for($property)->create(); + $primary = BlockedPeriod::factory()->for($property)->create(['starts_on' => '2027-05-23', 'ends_on' => '2027-05-30']); + $copy = $this->block($property, $channel, 'copy'); + $this->actingAs(User::factory()->create()); + + Livewire::test(ManageBlockedPeriods::class)->callTableAction('resolve', $copy, ['resolution' => 'block', 'target_id' => $primary->id])->assertHasNoActionErrors(); + + $this->assertSame($primary->id, $copy->fresh()->canonical_block_id); + $this->assertTrue($copy->fresh()->is_representation); + } + + public function test_content_role_cannot_open_the_occupation_resolution_screen(): void + { + $this->property(); + $this->actingAs(User::factory()->role(UserRole::Content)->create()); + + Livewire::test(ManageBlockedPeriods::class)->assertForbidden(); + } + + public function test_any_portal_created_in_the_ui_automatically_gets_its_own_stable_export_link(): void + { + $property = $this->property(); + $this->actingAs(User::factory()->create()); + $ui = Livewire::test(ChannelsRelationManager::class, ['ownerRecord' => $property, 'pageClass' => EditProperty::class]); + foreach (['Portal Alpha', 'Portal Beta', 'Ein beliebiger weiterer Anbieter'] as $name) { + $ui->callAction(TestAction::make(CreateAction::class)->table(), ['name' => $name, 'connector' => 'ical'])->assertHasNoFormErrors(); + } + + $channels = $property->channels()->get(); + $links = $channels->map(fn (Channel $channel): string => $channel->exportUrl()); + $this->assertSame(3, $links->unique()->count()); + foreach ($channels as $channel) { + $this->assertSame(48, strlen($channel->export_token)); + $link = $channel->exportUrl(); + $channel->update(['name' => $channel->name.' umbenannt']); + $this->assertSame($link, $channel->fresh()->exportUrl()); + $this->get($link)->assertStatus(503); + } + } + + private function property(): Property + { + $this->travelTo(CarbonImmutable::parse('2026-10-27 12:00')); + $this->seed(PropertySeeder::class); + $property = Property::sole(); + app(TenantContext::class)->set($property->tenant); + + return $property; + } + + private function block(Property $property, Channel $channel, string $uid): BlockedPeriod + { + return BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => $uid, 'starts_on' => '2027-05-23', 'ends_on' => '2027-05-30']); + } + + private function available(Property $property): bool + { + return app(AvailabilityChecker::class)->isAvailable($property, CarbonImmutable::parse('2027-05-23'), CarbonImmutable::parse('2027-05-30')); + } + + private static function feed(string $uid, string $start = '20270523', string $end = '20270530'): string + { + return "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Synthetic//DE\r\nBEGIN:VEVENT\r\nUID:{$uid}\r\nDTSTAMP:20261027T090000Z\r\nDTSTART;VALUE=DATE:{$start}\r\nDTEND;VALUE=DATE:{$end}\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"; + } +} diff --git a/tests/Feature/ChannelSyncTest.php b/tests/Feature/ChannelSyncTest.php index daad725..a0cb1c1 100644 --- a/tests/Feature/ChannelSyncTest.php +++ b/tests/Feature/ChannelSyncTest.php @@ -61,6 +61,7 @@ public function test_parser_reads_dates_datetimes_folded_lines_and_skips_cancell { $ics = implode("\r\n", [ 'BEGIN:VCALENDAR', + 'VERSION:2.0', 'PRODID:-//Synthetic Test//EN', 'BEGIN:VEVENT', 'UID:a1', 'DTSTART;VALUE=DATE:20261107', 'DTEND;VALUE=DATE:20261110', 'SUMMARY:Reserviert \, Familie', 'END:VEVENT', 'BEGIN:VEVENT', 'UID:a2', 'DTSTART;TZID=Europe/Berlin:20261201T160000', 'DTEND;TZID=Europe/Berlin:20261205T100000', 'END:VEVENT', 'BEGIN:VEVENT', 'UID:a3-very-long-uid-that-is-', ' folded', 'DTSTART:20261231T230000Z', 'DTEND:20270102T090000Z', 'END:VEVENT', @@ -69,6 +70,7 @@ public function test_parser_reads_dates_datetimes_folded_lines_and_skips_cancell 'END:VCALENDAR', ]); + $ics = str_replace("BEGIN:VEVENT\r\n", "BEGIN:VEVENT\r\nDTSTAMP:20261022T080000Z\r\n", $ics); $periods = (new ICalParser)->parse($ics); $this->assertSame( @@ -99,7 +101,9 @@ public function test_sync_adds_changes_and_removes_imported_occupations(): void $this->fakeFeed([['x1', '20261107', '20261111']]); $second = (new SyncChannel)->handle($channel); - $this->assertSame([0, 1, 1], [$second->added, $second->changed, $second->removed]); + $this->assertSame([0, 1, 0], [$second->added, $second->changed, $second->removed]); + $third = (new SyncChannel)->handle($channel); + $this->assertSame([0, 0, 1], [$third->added, $third->changed, $third->removed]); $this->assertSame('2026-11-11', $channel->blockedPeriods()->sole()->ends_on->toDateString()); $this->assertNotNull($channel->fresh()->last_success_at); } @@ -251,6 +255,9 @@ public function test_channels_are_managed_and_tasks_completed_in_the_admin(): vo ->callAction(TestAction::make(CreateAction::class)->table(), [ 'name' => 'FeWo-direkt', 'connector' => 'ical', + 'status' => 'active', + 'import_enabled' => true, + 'export_enabled' => true, 'settings' => ['import_url' => 'https://www.fewo-direkt.de/icalendar/abc.ics'], 'requires_manual_blocking' => true, 'manage_url' => 'https://www.fewo-direkt.de/vermieter/kalender', @@ -282,8 +289,8 @@ private function channel(string $name, bool $manual = false): Channel */ private function fakeFeed(array $events): void { - $body = "BEGIN:VCALENDAR\r\n".collect($events) - ->map(fn (array $event): string => "BEGIN:VEVENT\r\nUID:{$event[0]}\r\nDTSTART;VALUE=DATE:{$event[1]}\r\nDTEND;VALUE=DATE:{$event[2]}\r\nEND:VEVENT\r\n") + $body = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Synthetic Test//EN\r\n".collect($events) + ->map(fn (array $event): string => "BEGIN:VEVENT\r\nDTSTAMP:20261022T080000Z\r\nUID:{$event[0]}\r\nDTSTART;VALUE=DATE:{$event[1]}\r\nDTEND;VALUE=DATE:{$event[2]}\r\nEND:VEVENT\r\n") ->implode('')."END:VCALENDAR\r\n"; $this->httpResponse = Http::response($body, 200, ['Content-Type' => 'text/calendar']); diff --git a/tests/Feature/GenericChannelIntegrationTest.php b/tests/Feature/GenericChannelIntegrationTest.php new file mode 100644 index 0000000..f422c5c --- /dev/null +++ b/tests/Feature/GenericChannelIntegrationTest.php @@ -0,0 +1,593 @@ +travelTo(CarbonImmutable::parse('2026-11-01 10:00')); + } + + public function test_new_channel_has_safe_defaults_and_does_not_expose_an_empty_paused_calendar(): void + { + $property = $this->property(); + $channel = app(ConfigureChannel::class)->handle($property, ['name' => 'Beliebiges Portal', 'connector' => 'ical']); + + $this->assertSame([ChannelStatus::Setup, false, false, ChannelExportMode::Test], [$channel->status, $channel->import_enabled, $channel->export_enabled, $channel->export_mode]); + $this->get($channel->exportUrl())->assertStatus(503)->assertHeader('Retry-After', '300')->assertDontSee('BEGIN:VCALENDAR'); + } + + /** @return array */ + public static function directionProvider(): array + { + return ['import' => [true, false], 'export' => [false, true], 'both' => [true, true], 'neither' => [false, false]]; + } + + #[DataProvider('directionProvider')] + public function test_directions_are_independent(bool $import, bool $export): void + { + $property = $this->property(); + $channel = $this->channel($property, ['import_enabled' => $import, 'export_enabled' => $export]); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed())]); + + $result = app(SyncChannel::class)->handle($channel); + + $this->assertSame($import, $result->successful); + $this->get($channel->exportUrl())->assertStatus($export ? 200 : 503); + if (! $import) { + Http::assertNothingSent(); + } else { + Http::assertSentCount(1); + } + } + + public function test_test_mode_exports_only_own_occupations_but_foreign_ones_still_block_internally(): void + { + $property = $this->property(); + $a = $this->channel($property, ['export_mode' => 'test']); + $b = $this->channel($property); + $own = BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-02', 'ends_on' => '2026-11-03']); + $foreign = BlockedPeriod::factory()->for($property)->create(['channel_id' => $b->id, 'source' => 'channel', 'external_uid' => 'b1', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + $mail = BlockedPeriod::factory()->for($property)->create(['channel_id' => $b->id, 'source' => 'email', 'starts_on' => '2026-11-12', 'ends_on' => '2026-11-13']); + $booking = Booking::factory()->for($property)->create(['status' => BookingStatus::Confirmed, 'source' => 'manual']); + $portalBooking = Booking::factory()->for($property)->create(['status' => BookingStatus::Confirmed, 'source' => 'website', 'origin_channel_id' => $b->id]); + $importedBooking = Booking::factory()->for($property)->create(['status' => BookingStatus::Confirmed, 'source' => 'website', 'import_channel_id' => $b->id]); + + $feed = $this->get($a->exportUrl())->assertOk()->getContent(); + + $this->assertStringContainsString("UID:block-{$own->id}@fewo-stommer", $feed); + $this->assertStringContainsString("UID:booking-{$booking->id}@fewo-stommer", $feed); + foreach ([$foreign, $mail] as $block) { + $this->assertStringNotContainsString("UID:block-{$block->id}@fewo-stommer", $feed); + } + foreach ([$portalBooking, $importedBooking] as $block) { + $this->assertStringNotContainsString("UID:booking-{$block->id}@fewo-stommer", $feed); + } + $this->assertFalse(app(AvailabilityChecker::class)->isAvailable($property, CarbonImmutable::parse('2026-11-07'), CarbonImmutable::parse('2026-11-10'))); + $this->assertNotNull($a->fresh()->last_export_requested_at); + } + + public function test_regular_mode_excludes_both_the_import_channel_and_known_original_channel(): void + { + $property = $this->property(); + $a = $this->channel($property); + $b = $this->channel($property); + $origin = BlockedPeriod::factory()->for($property)->create(['channel_id' => $b->id, 'origin_channel_id' => $a->id, 'source' => 'channel']); + $other = BlockedPeriod::factory()->for($property)->create(['channel_id' => $b->id, 'source' => 'channel']); + $portalBooking = Booking::factory()->for($property)->create(['status' => BookingStatus::Confirmed, 'import_channel_id' => $b->id, 'origin_channel_id' => $a->id]); + + $feed = $this->get($a->exportUrl())->assertOk()->getContent(); + + $this->assertStringNotContainsString("UID:block-{$origin->id}@fewo-stommer", $feed); + $this->assertStringNotContainsString("UID:booking-{$portalBooking->id}@fewo-stommer", $feed); + $this->assertStringContainsString("UID:block-{$other->id}@fewo-stommer", $feed); + } + + public function test_paused_export_freezes_the_last_response_and_resume_refreshes_it(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $block = BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + $before = $this->get($channel->exportUrl())->assertOk()->getContent(); + + app(ConfigureChannel::class)->handle($property, ['export_enabled' => false], $channel); + $block->update(['ends_on' => '2026-11-11']); + + $this->get($channel->exportUrl())->assertOk()->assertHeader('X-Fewo-Export-State', 'frozen')->assertContent($before); + $this->assertTrue($channel->fresh()->importsOccupations()); + app(ConfigureChannel::class)->handle($property, ['export_enabled' => true], $channel); + $this->get($channel->exportUrl())->assertOk()->assertHeader('X-Fewo-Export-State', 'live')->assertSee('20261111'); + } + + public function test_pause_before_first_request_captures_the_existing_export_and_pauses_import(): void + { + $property = $this->property(); + $channel = $this->channel($property); + BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + Http::preventStrayRequests(); + + app(ConfigureChannel::class)->handle($property, ['status' => 'paused'], $channel); + + $this->get($channel->exportUrl())->assertOk()->assertHeader('X-Fewo-Export-State', 'frozen')->assertSee('20261107'); + $this->assertFalse(app(SyncChannel::class)->handle($channel)->successful); + $this->assertSame(1, $property->blockedPeriods()->count()); + Http::assertNothingSent(); + } + + public function test_repeated_import_and_identical_duplicate_uids_are_idempotent_and_echoes_are_ignored(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $event = self::event('external-1'); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed($event.$event.self::event('block-123@fewo-stommer')))]); + Mail::fake(); + + $first = app(SyncChannel::class)->handle($channel); + $id = $channel->blockedPeriods()->sole()->id; + $second = app(SyncChannel::class)->handle($channel); + + $this->assertSame([1, 1, 0], [$first->events, $first->added, $second->added]); + $this->assertSame($id, $channel->blockedPeriods()->sole()->id); + } + + /** @return array */ + public static function invalidFeedProvider(): array + { + $valid = self::feed(self::event('external-1')); + + return [ + 'not calendar' => ['Login'], + 'only marker' => ["BEGIN:VCALENDAR\r\n"], + 'truncated' => [str_replace('END:VCALENDAR', 'BEGIN:VEVENT', $valid)], + 'bad event' => [str_replace('END:VEVENT', '', $valid)], + 'invalid date' => [str_replace('20261107', '20261131', $valid)], + 'missing UID' => [str_replace("UID:external-1\r\n", '', $valid)], + 'missing stamp' => [str_replace("DTSTAMP:20261101T090000Z\r\n", '', $valid)], + 'recurrence' => [str_replace('UID:external-1', "UID:external-1\r\nRRULE:FREQ=DAILY;COUNT=3", $valid)], + 'different dates for same UID' => [self::feed(self::event('same').self::event('same', '20261114', '20261117'))], + 'different value types' => [str_replace('DTEND;VALUE=DATE:20261110', 'DTEND:20261110T100000Z', $valid)], + 'delta message' => [str_replace('VERSION:2.0', "VERSION:2.0\r\nMETHOD:CANCEL", $valid)], + ]; + } + + #[DataProvider('invalidFeedProvider')] + public function test_invalid_snapshot_never_changes_existing_blocks(string $body): void + { + $property = $this->property(); + $channel = $this->channel($property); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => 'existing', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response($body)]); + + $result = app(SyncChannel::class)->handle($channel); + + $this->assertFalse($result->successful); + $this->assertSame([$block->id, '2026-11-10', 0], [$channel->blockedPeriods()->sole()->id, $block->fresh()->ends_on->toDateString(), $block->fresh()->missing_imports]); + $this->assertNotNull($channel->fresh()->last_error_at); + $this->assertNull($channel->fresh()->last_success_at); + Http::assertSentCount(1); + } + + public function test_missing_events_require_two_successful_snapshots_and_reappearance_resets_confirmation(): void + { + $property = $this->property(); + $channel = $this->channel($property); + Mail::fake(); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::sequence() + ->push(self::feed(self::event('one')))->push(self::feed()) + ->push(self::feed(self::event('one')))->push(self::feed())->push(self::feed())]); + app(SyncChannel::class)->handle($channel); + + $first = app(SyncChannel::class)->handle($channel); + + $this->assertSame(0, $first->removed); + $this->assertSame(1, $channel->blockedPeriods()->sole()->missing_imports); + $channel->update(['import_enabled' => false]); + $this->assertFalse(app(SyncChannel::class)->handle($channel)->successful); + $this->assertSame(1, $channel->blockedPeriods()->count()); + $channel->update(['import_enabled' => true]); + app(SyncChannel::class)->handle($channel); + $this->assertSame(0, $channel->blockedPeriods()->sole()->missing_imports); + app(SyncChannel::class)->handle($channel); + $this->assertSame(1, app(SyncChannel::class)->handle($channel)->removed); + $this->assertSame(0, $channel->blockedPeriods()->count()); + } + + public function test_large_disappearance_is_held_for_review_instead_of_mass_removal(): void + { + $property = $this->property(); + $channel = $this->channel($property); + BlockedPeriod::factory()->count(6)->for($property)->sequence(fn ($sequence) => ['channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => 'id-'.$sequence->index, 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10'])->create(); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed())]); + + app(SyncChannel::class)->handle($channel); + $result = app(SyncChannel::class)->handle($channel); + + $this->assertSame(0, $result->removed); + $this->assertSame(6, $channel->blockedPeriods()->where('needs_review', true)->count()); + $this->assertNotEmpty($channel->fresh()->sync_warnings); + } + + public function test_changed_dates_keep_identity_and_preserve_old_dates_for_after_commit_tasks(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $target = $this->channel($property, ['requires_manual_blocking' => true]); + Mail::fake(); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::sequence()->push(self::feed(self::event('one')))->push(self::feed(self::event('one', '20261114', '20261117')))]); + app(SyncChannel::class)->handle($channel); + $id = $channel->blockedPeriods()->sole()->id; + $cutoff = ChannelTask::max('id'); + + $result = app(SyncChannel::class)->handle($channel); + + $this->assertSame([1, $id], [$result->changed, $channel->blockedPeriods()->sole()->id]); + $this->assertSame([['unblock', '2026-11-07', '2026-11-10'], ['block', '2026-11-14', '2026-11-17']], $target->tasks()->where('id', '>', $cutoff)->orderBy('id')->get()->map(fn ($task) => [$task->action->value, $task->starts_on->toDateString(), $task->ends_on->toDateString()])->all()); + } + + public function test_unblock_tasks_release_only_currently_free_nights(): void + { + $property = $this->property(); + $target = $this->channel($property, ['requires_manual_blocking' => true]); + Mail::fake(); + $outer = BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-07', 'ends_on' => '2026-11-11']); + BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-08', 'ends_on' => '2026-11-10']); + $cutoff = ChannelTask::max('id'); + + $outer->delete(); + + $this->assertSame([['2026-11-07', '2026-11-08'], ['2026-11-10', '2026-11-11']], $target->tasks()->where('id', '>', $cutoff)->where('action', ChannelTaskAction::Unblock)->orderBy('id')->get()->map(fn ($task) => [$task->starts_on->toDateString(), $task->ends_on->toDateString()])->all()); + } + + public function test_mail_and_calendar_merge_only_with_a_shared_identifier(): void + { + $property = $this->property(); + $channel = $this->channel($property, ['settings' => ['email_senders' => 'portal.example', 'import_url' => 'https://portal.example/feed.ics']]); + Mail::fake(); + $mail = app(ProcessPortalMail::class)->handle(new PortalMail('message-1', 'mail@portal.example', 'Neue Buchung', "Anreise: 07.11.2026\nAbreise: 10.11.2026\nBuchungsnummer: HA-TEST01", now()->toImmutable())); + $id = $mail->blocked_period_id; + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed(self::event('HA-TEST01', '20261114', '20261117')))]); + + app(SyncChannel::class)->handle($channel); + + $this->assertSame([$id, 'channel', '2026-11-14'], [$channel->blockedPeriods()->sole()->id, $channel->blockedPeriods()->sole()->source, $channel->blockedPeriods()->sole()->starts_on->toDateString()]); + } + + public function test_unidentified_nonoverlapping_mail_and_calendar_events_are_retained_separately(): void + { + $property = $this->property(); + $channel = $this->channel($property); + BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'email', 'external_uid' => 'email:HA-TEST01', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed(self::event('different', '20261114', '20261117')))]); + Mail::fake(); + + app(SyncChannel::class)->handle($channel); + + $this->assertSame(2, $channel->blockedPeriods()->where('needs_review', true)->count()); + } + + public function test_test_mode_does_not_dispatch_foreign_occupations_to_manual_portals(): void + { + $property = $this->property(); + $a = $this->channel($property); + $b = $this->channel($property, ['export_mode' => 'test', 'requires_manual_blocking' => true]); + Mail::fake(); + + BlockedPeriod::factory()->for($property)->create(['channel_id' => $a->id, 'source' => 'channel']); + + $this->assertSame(0, $b->tasks()->count()); + Mail::assertNothingSent(); + } + + public function test_token_rotation_keeps_old_link_during_explicit_transition_and_hides_tokens_from_serialisation(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $oldUrl = $channel->exportUrl(); + + $rotated = app(RotateChannelToken::class)->handle($channel, 24); + + $this->assertNotSame($oldUrl, $rotated->exportUrl()); + $this->get($oldUrl)->assertOk(); + $this->get($rotated->exportUrl())->assertOk(); + $this->assertArrayNotHasKey('export_token', $rotated->toArray()); + $this->assertArrayNotHasKey('previous_export_token', $rotated->toArray()); + $this->travel(25)->hours(); + $this->get($oldUrl)->assertNotFound(); + $this->get($rotated->exportUrl())->assertOk(); + } + + public function test_second_rotation_cannot_silently_revoke_a_running_transition(): void + { + $property = $this->property(); + $channel = $this->channel($property); + app(RotateChannelToken::class)->handle($channel); + + $this->expectException(ValidationException::class); + app(RotateChannelToken::class)->handle($channel); + } + + public function test_foreign_channel_provenance_cannot_be_assigned_to_another_property(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $other = Property::factory()->create(); + + $this->expectException(ValidationException::class); + BlockedPeriod::factory()->for($other)->create(['channel_id' => $channel->id]); + } + + public function test_two_properties_and_their_channels_do_not_share_imports_or_exports(): void + { + $property = $this->property(); + $other = Property::factory()->create(); + $a = $this->channel($property); + $b = $this->channel($other); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response(self::feed(self::event('a1')))]); + Mail::fake(); + + app(SyncChannel::class)->handle($a); + + $this->assertSame(0, $b->blockedPeriods()->count()); + $this->assertTrue(app(AvailabilityChecker::class)->isAvailable($other, CarbonImmutable::parse('2026-11-07'), CarbonImmutable::parse('2026-11-10'))); + $this->get($b->exportUrl())->assertOk()->assertDontSee('20261107'); + } + + public function test_admin_can_configure_directions_and_edit_confidential_import_address(): void + { + $property = $this->property(); + $this->actingAs(User::factory()->create()); + $component = Livewire::test(ChannelsRelationManager::class, ['ownerRecord' => $property, 'pageClass' => EditProperty::class]); + $component->callAction(TestAction::make(CreateAction::class)->table(), ['name' => 'Portal A', 'connector' => 'ical', 'status' => 'active', 'booking_model' => 'inquiry', 'import_enabled' => true, 'export_enabled' => false, 'export_mode' => 'test', 'settings' => ['import_url' => 'https://portal.example/secret.ics'], 'external_poll_minutes' => 1440])->assertHasNoFormErrors(); + $channel = $property->channels()->sole(); + + $component->callAction(TestAction::make(EditAction::class)->table($channel), ['export_enabled' => true, 'external_poll_minutes' => 30])->assertHasNoFormErrors(); + + $this->assertSame([true, true, 30, 'https://portal.example/secret.ics'], [$channel->fresh()->import_enabled, $channel->fresh()->export_enabled, $channel->fresh()->external_poll_minutes, $channel->fresh()->setting('import_url')]); + } + + public function test_failed_fetch_preserves_occupations_and_does_not_disclose_import_url(): void + { + $property = $this->property(); + $channel = $this->channel($property, ['settings' => ['import_url' => 'https://portal.example/private-token.ics']]); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => 'one']); + Http::preventStrayRequests(); + Http::fake(['https://portal.example/*' => Http::response('error', 403)]); + + $result = app(SyncChannel::class)->handle($channel); + + $this->assertFalse($result->successful); + $this->assertModelExists($block); + $this->assertStringNotContainsString('private-token', $channel->fresh()->last_error); + $this->assertSame(0, $block->fresh()->missing_imports); + } + + public function test_source_address_cannot_silently_replace_an_existing_import_inventory(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'channel']); + + try { + app(ConfigureChannel::class)->handle($property, ['settings' => ['import_url' => 'https://other.example/new.ics']], $channel); + $this->fail('Changing the inventory source must require a separate migration decision.'); + } catch (ValidationException $exception) { + $this->assertArrayHasKey('settings.import_url', $exception->errors()); + } + $this->assertModelExists($block); + $this->assertStringStartsWith('https://portal.example/', $channel->fresh()->setting('import_url')); + } + + public function test_a_channel_lock_prevents_a_second_fetch(): void + { + $property = $this->property(); + $channel = $this->channel($property); + Http::preventStrayRequests(); + Http::fake(); + $lock = Cache::lock("channel-sync:{$channel->tenant_id}:{$channel->id}", 120); + $this->assertTrue($lock->get()); + + try { + $result = app(SyncChannel::class)->handle($channel); + $this->assertFalse($result->successful); + Http::assertNothingSent(); + } finally { + $lock->release(); + } + } + + public function test_ambiguous_mail_sender_never_selects_the_first_property(): void + { + $property = $this->property(); + $other = Property::factory()->create(); + $a = $this->channel($property, ['settings' => ['email_senders' => 'portal.example']]); + $b = $this->channel($other, ['settings' => ['email_senders' => 'portal.example']]); + Mail::fake(); + + $result = app(ProcessPortalMail::class)->handle(new PortalMail('ambiguous', 'mail@portal.example', 'Neue Buchung', 'Anreise: 07.11.2026 Abreise: 10.11.2026', now()->toImmutable())); + + $this->assertNull($result); + $this->assertSame(0, BlockedPeriod::count()); + $this->assertNotEmpty($a->fresh()->sync_warnings); + $this->assertNotEmpty($b->fresh()->sync_warnings); + Mail::assertNothingSent(); + } + + public function test_rolled_back_occupations_do_not_create_portal_tasks(): void + { + $property = $this->property(); + $channel = $this->channel($property, ['requires_manual_blocking' => true]); + Mail::fake(); + DB::beginTransaction(); + BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + + DB::rollBack(); + + $this->assertSame(0, $channel->tasks()->count()); + Mail::assertNothingSent(); + } + + public function test_outdated_unblock_task_is_not_sent_to_external_automation(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $task = $channel->tasks()->create(['action' => 'unblock', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10', 'reason' => 'Synthetic release']); + BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-08', 'ends_on' => '2026-11-09']); + config(['fewo.automation.webhook_url' => 'https://bot.example/tasks', 'fewo.automation.secret' => 'synthetic-secret']); + Http::preventStrayRequests(); + Http::fake(); + + app(CreateChannelTasks::class)->sendToAutomation($task); + + $this->assertSame('dismissed', $task->fresh()->status->value); + Http::assertNothingSent(); + } + + public function test_export_folds_long_utf8_lines_and_round_trips_without_date_changes(): void + { + $property = $this->property(); + $property->update(['name' => str_repeat('Kühlungsborn ', 12)]); + $channel = $this->channel($property); + BlockedPeriod::factory()->for($property)->create(['starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + + $body = $this->get($channel->exportUrl())->assertOk()->getContent(); + + foreach (explode("\r\n", $body) as $line) { + $this->assertLessThanOrEqual(75, strlen($line)); + } + $period = app(ICalParser::class)->parse($body)[0]; + $this->assertSame(['2026-11-07', '2026-11-10'], [$period->startsOn->toDateString(), $period->endsOn->toDateString()]); + } + + public function test_outdated_block_task_is_not_sent_after_cancellation(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $task = $channel->tasks()->create(['action' => 'block', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10', 'reason' => 'Old synthetic occupation']); + config(['fewo.automation.webhook_url' => 'https://bot.example/tasks', 'fewo.automation.secret' => 'synthetic-secret']); + Http::preventStrayRequests(); + Http::fake(); + + app(CreateChannelTasks::class)->sendToAutomation($task); + + $this->assertSame('dismissed', $task->fresh()->status->value); + Http::assertNothingSent(); + } + + public function test_cancellation_without_shared_reference_retains_mail_block_for_review(): void + { + $property = $this->property(); + $channel = $this->channel($property, ['settings' => ['email_senders' => 'portal.example']]); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'email', 'external_uid' => 'email:known', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + Mail::fake(); + + $record = app(ProcessPortalMail::class)->handle(new PortalMail('cancel-unknown', 'mail@portal.example', 'Buchung storniert', 'Die Buchung vom 07.11.2026 bis 10.11.2026 wurde storniert.', now()->toImmutable())); + + $this->assertSame('needs_review', $record->status->value); + $this->assertModelExists($block); + } + + public function test_upgrade_preserves_existing_directions_scope_token_and_inventory(): void + { + $property = $this->property(); + $channel = $this->channel($property); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => 'old']); + $token = $channel->export_token; + $migration = require database_path('migrations/2026_10_27_154125_add_generic_ical_controls_and_provenance.php'); + + $migration->down(); + $migration->up(); + + $this->assertSame([true, true, ChannelExportMode::Regular, $token], [$channel->fresh()->import_enabled, $channel->fresh()->export_enabled, $channel->fresh()->export_mode, $channel->fresh()->export_token]); + $this->assertModelExists($block); + $this->assertSame('old', $block->fresh()->external_uid); + } + + public function test_admin_can_view_import_provenance_and_unresolved_block_review(): void + { + $property = $this->property(); + $channel = $this->channel($property, ['name' => 'Synthetisches Portal']); + $block = BlockedPeriod::factory()->for($property)->create(['channel_id' => $channel->id, 'origin_channel_id' => $channel->id, 'source' => 'channel', 'external_uid' => 'synthetic-uid', 'needs_review' => true, 'review_note' => 'Bestand persönlich prüfen', 'starts_on' => '2026-11-07', 'ends_on' => '2026-11-10']); + $this->actingAs(User::factory()->create()); + + Livewire::test(ManageBlockedPeriods::class) + ->assertCanSeeTableRecords([$block]) + ->assertSee('Synthetisches Portal') + ->assertSee('Bitte prüfen') + ->assertSee('Bestand persönlich prüfen'); + } + + private function property(): Property + { + $this->seed(PropertySeeder::class); + $property = Property::sole(); + app(TenantContext::class)->set($property->tenant); + + return $property; + } + + /** @param array $attributes */ + private function channel(Property $property, array $attributes = []): Channel + { + return Channel::factory()->for($property)->create($attributes); + } + + private static function event(string $uid, string $start = '20261107', string $end = '20261110'): string + { + return "BEGIN:VEVENT\r\nUID:{$uid}\r\nDTSTAMP:20261101T090000Z\r\nDTSTART;VALUE=DATE:{$start}\r\nDTEND;VALUE=DATE:{$end}\r\nSUMMARY:Belegt\r\nEND:VEVENT\r\n"; + } + + private static function feed(string $events = ''): string + { + return "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Synthetic Test//EN\r\n{$events}END:VCALENDAR\r\n"; + } +} diff --git a/tests/Feature/PortalMailTest.php b/tests/Feature/PortalMailTest.php index 41da38c..e6aacde 100644 --- a/tests/Feature/PortalMailTest.php +++ b/tests/Feature/PortalMailTest.php @@ -113,7 +113,7 @@ public function test_overlap_with_an_existing_booking_raises_a_conflict(): void Mail::assertSent(ChannelConflict::class); } - public function test_calendar_sync_confirms_the_mail_block_without_creating_new_tasks(): void + public function test_calendar_without_shared_identity_keeps_the_mail_block_for_review(): void { Channel::factory()->for($this->property)->create(['name' => 'Ostseeklar', 'requires_manual_blocking' => true]); $this->process('Neue Buchung', self::BOOKING_MAIL); @@ -122,19 +122,21 @@ public function test_calendar_sync_confirms_the_mail_block_without_creating_new_ $this->fakeFeed("UID:vrbo-123\r\nDTSTART;VALUE=DATE:20261107\r\nDTEND;VALUE=DATE:20261110"); (new SyncChannel)->handle($this->fewo); - $block = $this->fewo->blockedPeriods()->sole(); - $this->assertSame(['channel', 'vrbo-123'], [$block->source, $block->external_uid]); + $this->assertSame(2, $this->fewo->blockedPeriods()->count()); + $this->assertSame(2, $this->fewo->blockedPeriods()->where('needs_review', true)->count()); $this->assertSame($tasksBefore, ChannelTask::count()); } - public function test_calendar_entry_with_other_dates_replaces_the_mail_block(): void + public function test_calendar_entry_with_overlapping_dates_does_not_replace_an_unidentified_mail_block(): void { $this->process('Neue Buchung', self::BOOKING_MAIL); $this->fakeFeed("UID:vrbo-123\r\nDTSTART;VALUE=DATE:20261107\r\nDTEND;VALUE=DATE:20261111"); (new SyncChannel)->handle($this->fewo); - $this->assertSame(['channel', '2026-11-11'], [$this->fewo->blockedPeriods()->sole()->source, $this->fewo->blockedPeriods()->sole()->ends_on->toDateString()]); + $this->assertSame(2, $this->fewo->blockedPeriods()->count()); + $this->assertSame(1, $this->fewo->blockedPeriods()->where('source', 'email')->count()); + $this->assertSame('2026-11-11', $this->fewo->blockedPeriods()->where('source', 'channel')->sole()->ends_on->toDateString()); } public function test_mail_blocks_survive_a_calendar_sync_that_does_not_know_them_yet(): void @@ -206,7 +208,7 @@ private function process(string $subject, string $text, string $messageId = 'msg private function fakeFeed(string $event): void { - $body = "BEGIN:VCALENDAR\r\n".($event !== '' ? "BEGIN:VEVENT\r\n{$event}\r\nEND:VEVENT\r\n" : '').'END:VCALENDAR'; + $body = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Synthetic Test//EN\r\n".($event !== '' ? "BEGIN:VEVENT\r\nDTSTAMP:20261022T080000Z\r\n{$event}\r\nEND:VEVENT\r\n" : '').'END:VCALENDAR'; Http::fake(['*' => Http::response($body)]); } }