189 lines
7.3 KiB
PHP
189 lines
7.3 KiB
PHP
<?php
|
||
|
||
namespace App\Actions;
|
||
|
||
use App\Channels\ConflictDetector;
|
||
use App\Channels\Mail\ParsedPortalMail;
|
||
use App\Channels\Mail\PortalMail;
|
||
use App\Channels\Mail\PortalMailParser;
|
||
use App\Enums\PortalEmailStatus;
|
||
use App\Enums\PortalEmailType;
|
||
use App\Enums\TenantServiceKey;
|
||
use App\Mail\ChannelConflict;
|
||
use App\Mail\PortalMailNotification;
|
||
use App\Models\BlockedPeriod;
|
||
use App\Models\Channel;
|
||
use App\Models\PortalEmail;
|
||
use App\Support\Settings;
|
||
use App\Tenancy\TenantFeatures;
|
||
use Illuminate\Support\Facades\DB;
|
||
use Illuminate\Support\Facades\Mail;
|
||
|
||
/**
|
||
* Fast path for portal bookings: the notification e-mail usually arrives within a minute, long before
|
||
* the portal's calendar export is read. A recognised booking is blocked immediately; the later calendar
|
||
* sync confirms the block. Anything not recognised with confidence is flagged for review – never guessed.
|
||
*/
|
||
class ProcessPortalMail
|
||
{
|
||
public function __construct(
|
||
private PortalMailParser $parser,
|
||
private ConflictDetector $conflictDetector,
|
||
) {}
|
||
|
||
public function handle(PortalMail $mail): ?PortalEmail
|
||
{
|
||
if (PortalEmail::where('message_id', $mail->messageId)->exists()) {
|
||
return null;
|
||
}
|
||
|
||
$channel = $this->channelFor($mail->from);
|
||
if ($channel === null) {
|
||
return null;
|
||
}
|
||
|
||
// The fast path is a service of its own: a landlord without it keeps the mail unprocessed.
|
||
if (! app(TenantFeatures::class)->enabled(TenantServiceKey::PortalMail, $channel->tenant)) {
|
||
return null;
|
||
}
|
||
|
||
$parsed = $this->parser->parse($mail->subject, $mail->text);
|
||
$conflicts = [];
|
||
|
||
$record = DB::transaction(function () use ($mail, $channel, $parsed, &$conflicts): PortalEmail {
|
||
[$status, $block, $note] = match ($parsed->type) {
|
||
PortalEmailType::Booking => $this->block($channel, $parsed, $conflicts),
|
||
PortalEmailType::Cancellation => $this->release($channel, $parsed),
|
||
PortalEmailType::Inquiry => [PortalEmailStatus::Ignored, null, 'Anfrage – keine Sperre nötig.'],
|
||
PortalEmailType::Unknown => [PortalEmailStatus::NeedsReview, null, 'Inhalt nicht erkannt.'],
|
||
};
|
||
|
||
return PortalEmail::create([
|
||
'channel_id' => $channel->id,
|
||
'message_id' => $mail->messageId,
|
||
'from' => mb_substr($mail->from, 0, 255),
|
||
'subject' => mb_substr($mail->subject, 0, 255),
|
||
'received_at' => $mail->receivedAt,
|
||
'type' => $parsed->type,
|
||
'status' => $status,
|
||
'starts_on' => $parsed->startsOn?->toDateString(),
|
||
'ends_on' => $parsed->endsOn?->toDateString(),
|
||
'reference' => $parsed->reference,
|
||
'blocked_period_id' => $block?->id,
|
||
'excerpt' => mb_substr(trim(preg_replace('/\s+/u', ' ', strip_tags($mail->text))), 0, 500),
|
||
'note' => $note,
|
||
]);
|
||
});
|
||
|
||
if (in_array($record->status, [PortalEmailStatus::Blocked, PortalEmailStatus::Released, PortalEmailStatus::NeedsReview], true)) {
|
||
rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new PortalMailNotification($record)));
|
||
}
|
||
|
||
if ($conflicts !== []) {
|
||
rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new ChannelConflict($channel, $conflicts)));
|
||
}
|
||
|
||
return $record;
|
||
}
|
||
|
||
/**
|
||
* Channels list the sender addresses or domains of their notification e-mails in settings.email_senders.
|
||
*/
|
||
public function channelFor(string $from): ?Channel
|
||
{
|
||
$from = mb_strtolower($from);
|
||
|
||
$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;
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* @return list<string>
|
||
*/
|
||
public function senders(Channel $channel): array
|
||
{
|
||
return array_values(array_filter(array_map(
|
||
fn (string $sender): string => mb_strtolower(trim($sender)),
|
||
explode(',', (string) $channel->setting('email_senders')),
|
||
)));
|
||
}
|
||
|
||
/**
|
||
* @param list<string> $conflicts
|
||
* @return array{PortalEmailStatus, ?BlockedPeriod, ?string}
|
||
*/
|
||
private function block(Channel $channel, ParsedPortalMail $parsed, array &$conflicts): array
|
||
{
|
||
if (! $parsed->hasPeriod()) {
|
||
return [PortalEmailStatus::NeedsReview, null, 'Buchung erkannt, aber An-/Abreise nicht sicher lesbar.'];
|
||
}
|
||
|
||
$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];
|
||
}
|
||
|
||
$block = $channel->blockedPeriods()->create([
|
||
'property_id' => $channel->property_id,
|
||
'starts_on' => $parsed->startsOn->toDateString(),
|
||
'ends_on' => $parsed->endsOn->toDateString(),
|
||
'reason' => "{$channel->name} (E-Mail)".($parsed->reference ? ": {$parsed->reference}" : ''),
|
||
'source' => 'email',
|
||
'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];
|
||
}
|
||
|
||
/**
|
||
* Only blocks created from e-mails are released here; calendar blocks disappear with the next sync.
|
||
*
|
||
* @return array{PortalEmailStatus, ?BlockedPeriod, ?string}
|
||
*/
|
||
private function release(Channel $channel, ParsedPortalMail $parsed): array
|
||
{
|
||
$emailBlocks = $channel->blockedPeriods()->where('source', 'email');
|
||
|
||
$block = match (true) {
|
||
$parsed->reference !== null => (clone $emailBlocks)->where('external_uid', 'email:'.$parsed->reference)->first(),
|
||
default => null,
|
||
};
|
||
|
||
if ($block) {
|
||
$block->delete();
|
||
|
||
return [PortalEmailStatus::Released, null, 'Sperre aus E-Mail aufgehoben.'];
|
||
}
|
||
|
||
return [PortalEmailStatus::NeedsReview, null, 'Stornierung erkannt – bitte prüfen; Kalender-Sperren verschwinden mit dem nächsten Abgleich.'];
|
||
}
|
||
}
|