Phase 4 und 5: Hintergrundläufe je Mandant, Export und Kündigung

**Phase 4 – was im Hintergrund lief, kannte keinen Mandanten.**

`App\Tenancy\TenantRunner` führt jeden Lauf einmal je aktivem Mandanten
aus, mit gesetztem Kontext. Ohne ihn sah der Scheduler bei zwei Mandanten
gar keinen: Abfragen filterten nicht mehr und der Absender fiel auf die
.env zurück – eine Erinnerung des einen Vermieters wäre unter der Adresse
des anderen verschickt worden. Seit gestern gibt es zwei Mandanten; nur
weil der Cronjob auf Strato noch nicht eingerichtet ist, ist das bisher
niemandem passiert.

Betroffen: Vormerkungen, Portal-Abgleich, Portal-Postfach, Überwachung,
Erinnerungen, Bewertungsbitten, Anonymisierung. Die Datenbank-Sicherung
bleibt global – eine Datenbank, ein Dump. Ein Mandant, dessen Lauf
scheitert, hält die anderen nicht auf.

Das Postfach gehört jetzt dem Mandanten (`mailbox_*`, Passwort
verschlüsselt, leerer Server = aus). Es steht im Mandanten-Admin und nur,
wenn der Betreiber den Dienst freigeschaltet hat. Auch die Zustands-
Schlüssel im Cache tragen den Mandanten – sonst meldeten zwei Mandanten
einander ihre letzte erfolgreiche Abholung.

**Phase 5 – Kündigung.**

`App\Tenancy\TenantArchive` mit zwei Befehlen des Betreibers:
`tenants:export <slug>` schreibt alle Zeilen und Dateien in ein Zip,
`tenants:delete <slug>` exportiert erst, fragt nach und löscht dann in
der Reihenfolge, die die Fremdschlüssel erlauben, Medien eingeschlossen.

Konten, die nur zu diesem Mandanten gehörten, gehen mit – ein Konto, das
nirgends mehr hineinkommt, ist personenbezogenes Datum ohne Zweck. Wer
noch für einen anderen Mandanten arbeitet, und der Betreiber, bleiben.
Der Export nennt die Konten mit Rolle, aber ohne Passwort-Hashes und ohne
2FA-Geheimnisse: er wird herausgegeben.

Löschen ist bewusst keine Schaltfläche im Panel.

`TenantSeparationTest` füllt jeden Bereich aus A1 für zwei Mandanten,
exportiert und löscht einen und prüft, dass der andere Zeile für Zeile
unverändert ist – auch die Hosts, die über die Website am Mandanten
hängen und keine eigene tenant_id haben. Dieser Test merkt künftig, wenn
eine neue Tabelle ihre tenant_id vergisst.

262 Feature-Tests grün. Der Export einmal auf echten Daten ausgeführt
(2,3 MB mit Fotos); das Löschen nicht, weil es Dateien aus dem echten
Speicher entfernt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Lars StommerandClaude Opus 5 committed 2026-10-24 11:15:55 +02:00
1 parent c2cf632ad5
commit c55937d20e
20 files changed
+986 -40

No files matched your search

+1
View File
@@ -32,3 +32,4 @@ Thumbs.db
# Deployment settings with access data
/scripts/deploy.*.env
!/scripts/deploy.example.env
storage/app/private/exports/
+2 -2
View File
@@ -38,7 +38,7 @@ public static function mailboxIsStale(): bool
return false;
}
$lastSuccess = Cache::get(MailboxReader::LAST_SUCCESS_KEY);
$lastSuccess = Cache::get(MailboxReader::key(MailboxReader::LAST_SUCCESS_KEY));
return $lastSuccess === null
|| CarbonImmutable::parse($lastSuccess)->lessThan(now()->subMinutes(config('fewo.mailbox.stale_after_minutes')));
@@ -56,7 +56,7 @@ private function monitorMailbox(): int
return 0;
}
Mail::to(Settings::notificationRecipients())->send(new MailboxAlert(Cache::get(MailboxReader::LAST_ERROR_KEY)));
Mail::to(Settings::notificationRecipients())->send(new MailboxAlert(Cache::get(MailboxReader::key(MailboxReader::LAST_ERROR_KEY))));
Cache::forever(self::MAILBOX_ALERTED_KEY, true);
return 1;
+30 -5
View File
@@ -3,6 +3,7 @@
namespace App\Channels\Mail;
use App\Channels\ChannelSyncException;
use App\Support\Settings;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\Cache;
use Throwable;
@@ -17,11 +18,31 @@ class MailboxReader
{
public const LAST_SUCCESS_KEY = 'mailbox:last_success_at';
/**
* The state of one landlord's mailbox. Without the landlord in the key, two landlords would report
* each other's last success and alerts would be raised for the wrong one.
*/
public static function key(string $base): string
{
return $base.':'.(Settings::tenant()?->id ?? 0);
}
public const LAST_ERROR_KEY = 'mailbox:last_error';
/**
* The mailbox of the current landlord. Each landlord reads their own; an empty one means the fast path
* is off for them.
*
* @return array<string, mixed>|null
*/
public static function configuration(): ?array
{
return Settings::tenant()?->mailbox();
}
public static function isConfigured(): bool
{
return filled(config('fewo.mailbox.host')) && filled(config('fewo.mailbox.username'));
return self::configuration() !== null;
}
/**
@@ -32,7 +53,11 @@ public static function isConfigured(): bool
*/
public function fetch(array $senders): array
{
$config = config('fewo.mailbox');
$config = self::configuration();
if ($config === null) {
throw new ChannelSyncException('Für diesen Mandanten ist kein Postfach hinterlegt.');
}
try {
$client = (new ClientManager)->make([
@@ -62,13 +87,13 @@ public function fetch(array $senders): array
$client->disconnect();
} catch (Throwable $exception) {
Cache::forever(self::LAST_ERROR_KEY, $exception->getMessage());
Cache::forever(self::key(self::LAST_ERROR_KEY), $exception->getMessage());
throw new ChannelSyncException('Postfach konnte nicht gelesen werden: '.$exception->getMessage(), previous: $exception);
}
Cache::forever(self::LAST_SUCCESS_KEY, now()->toIso8601String());
Cache::forget(self::LAST_ERROR_KEY);
Cache::forever(self::key(self::LAST_SUCCESS_KEY), now()->toIso8601String());
Cache::forget(self::key(self::LAST_ERROR_KEY));
return $mails;
}
+51
View File
@@ -0,0 +1,51 @@
<?php
namespace App\Console\Commands;
use App\Models\Tenant;
use App\Tenancy\TenantArchive;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
use function Laravel\Prompts\confirm;
#[Signature('tenants:delete {slug : Kurzname des Mandanten} {--keep-export : Nicht vorher exportieren} {--force : Ohne Rückfrage}')]
#[Description('Export a landlord and then remove them with all their data and files')]
class DeleteTenant extends Command
{
/**
* Exports first, unless told otherwise: a deletion that cannot be undone should leave something behind.
*/
public function handle(TenantArchive $archive): int
{
$tenant = Tenant::query()->where('slug', $this->argument('slug'))->first();
if ($tenant === null) {
$this->error('Kein Mandant mit dem Kurznamen '.$this->argument('slug').'.');
return self::FAILURE;
}
if (! $this->option('keep-export')) {
$path = $archive->export($tenant, storage_path('app/private/exports'));
$this->info('Export geschrieben: '.$path);
}
if (! $this->option('force') && ! confirm('Mandant '.$tenant->name.' mit allen Daten und Dateien endgültig löschen?', default: false)) {
$this->line('Abgebrochen.');
return self::SUCCESS;
}
$removed = $archive->delete($tenant);
foreach ($removed as $table => $count) {
$this->line(sprintf(' %-22s %d', $table, $count));
}
$this->info('Mandant '.$tenant->name.' gelöscht.');
return self::SUCCESS;
}
}
@@ -3,22 +3,26 @@
namespace App\Console\Commands;
use App\Actions\ExpireReservations;
use App\Models\Tenant;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('bookings:expire-holds')]
#[Description('Mark reservations with an elapsed hold time as expired and notify the landlord')]
#[Description('Mark reservations with an elapsed hold time as expired and notify the landlord – once per landlord')]
class ExpireReservationHolds extends Command
{
/**
* Execute the console command.
*/
public function handle(ExpireReservations $expireReservations): int
public function handle(ExpireReservations $expireReservations, TenantRunner $runner): int
{
$count = $expireReservations->handle();
$runner->each(function (Tenant $tenant) use ($expireReservations): void {
$count = $expireReservations->handle();
$this->info("{$count} Vormerkung(en) abgelaufen.");
$this->info("{$tenant->name}: {$count} Vormerkung(en) abgelaufen.");
});
return self::SUCCESS;
}
+40
View File
@@ -0,0 +1,40 @@
<?php
namespace App\Console\Commands;
use App\Models\Tenant;
use App\Tenancy\TenantArchive;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('tenants:export {slug : Kurzname des Mandanten} {--to= : Zielordner, sonst storage/app/private/exports}')]
#[Description('Write all data and files of one landlord into a zip archive')]
class ExportTenant extends Command
{
public function handle(TenantArchive $archive): int
{
$tenant = Tenant::query()->where('slug', $this->argument('slug'))->first();
if ($tenant === null) {
$this->error('Kein Mandant mit dem Kurznamen '.$this->argument('slug').'.');
return self::FAILURE;
}
$path = $archive->export($tenant, (string) ($this->option('to') ?: storage_path('app/private/exports')));
$this->info('Export von '.$tenant->name.': '.$path.' ('.$this->size($path).')');
return self::SUCCESS;
}
private function size(string $path): string
{
$bytes = (int) (filesize($path) ?: 0);
return $bytes > 1048576
? round($bytes / 1048576, 1).' MB'
: round($bytes / 1024).' KB';
}
}
+25 -14
View File
@@ -7,53 +7,64 @@
use App\Channels\Mail\MailboxReader;
use App\Enums\TenantServiceKey;
use App\Models\Channel;
use App\Models\Tenant;
use App\Tenancy\TenantFeatures;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('channels:fetch-mail')]
#[Description('Read booking notifications of the portals from the mailbox and block recognised bookings immediately')]
#[Description('Read booking notifications of the portals from each landlord\'s mailbox and block recognised bookings immediately')]
class FetchPortalMail extends Command
{
/**
* Execute the console command.
* Execute the console command. Every landlord has their own mailbox, so every landlord gets their own
* run – one landlord's credentials are never used to read another one's mail.
*/
public function handle(MailboxReader $reader, ProcessPortalMail $processPortalMail): int
public function handle(MailboxReader $reader, ProcessPortalMail $processPortalMail, TenantRunner $runner): int
{
if (! MailboxReader::isConfigured()) {
$this->line('Kein Postfach konfiguriert (FEWO_MAILBOX_HOST).');
$runner->each(fn (Tenant $tenant) => $this->fetchForCurrentLandlord($reader, $processPortalMail, $tenant));
return self::SUCCESS;
return self::SUCCESS;
}
private function fetchForCurrentLandlord(MailboxReader $reader, ProcessPortalMail $processPortalMail, Tenant $tenant): void
{
if (! app(TenantFeatures::class)->enabled(TenantServiceKey::PortalMail, $tenant)) {
return;
}
if (! MailboxReader::isConfigured()) {
$this->line("{$tenant->name}: kein Postfach hinterlegt.");
return;
}
$senders = Channel::query()->active()->get()
->filter(fn (Channel $channel): bool => app(TenantFeatures::class)->enabled(TenantServiceKey::PortalMail, $channel->tenant))
->flatMap(fn (Channel $channel): array => $processPortalMail->senders($channel))
->unique()
->values()
->all();
if ($senders === []) {
$this->line('Für kein Portal sind Absender hinterlegt.');
$this->line("{$tenant->name}: für kein Portal sind Absender hinterlegt.");
return self::SUCCESS;
return;
}
try {
$mails = $reader->fetch($senders);
} catch (ChannelSyncException $exception) {
$this->error($exception->getMessage());
$this->error("{$tenant->name}: {$exception->getMessage()}");
return self::FAILURE;
return;
}
foreach ($mails as $mail) {
if ($record = $processPortalMail->handle($mail)) {
$this->info("{$record->channel->name}: {$record->type->getLabel()} → {$record->status->getLabel()} ({$record->subject})");
$this->info("{$tenant->name} – {$record->channel->name}: {$record->type->getLabel()} → {$record->status->getLabel()} ({$record->subject})");
}
}
return self::SUCCESS;
}
}
+12 -5
View File
@@ -4,18 +4,27 @@
use App\Actions\SyncChannel;
use App\Models\Channel;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('channels:sync {channel? : ID of a single channel}')]
#[Description('Import the occupations of all active portals (or one) and report conflicts')]
#[Description('Import the occupations of all active portals (or one) and report conflicts – once per landlord')]
class SyncChannels extends Command
{
/**
* Execute the console command.
* Execute the console command. Runs per landlord so that conflict mails carry the right sender and
* reach the right people.
*/
public function handle(SyncChannel $syncChannel): int
public function handle(SyncChannel $syncChannel, TenantRunner $runner): int
{
$runner->each(fn () => $this->syncCurrentLandlord($syncChannel));
return self::SUCCESS;
}
private function syncCurrentLandlord(SyncChannel $syncChannel): void
{
$channels = Channel::query()->active()
->when($this->argument('channel'), fn ($query, $id) => $query->whereKey($id))
@@ -29,7 +38,5 @@ public function handle(SyncChannel $syncChannel): int
? $this->info("✓ {$channel->name}: {$log->events} Belegungen, +{$log->added} ~{$log->changed} -{$log->removed}, Konflikte: {$log->conflicts}")
: $this->error("✗ {$channel->name}: {$log->message}");
}
return self::SUCCESS;
}
}
+31
View File
@@ -2,14 +2,17 @@
namespace App\Filament\Pages;
use App\Enums\TenantServiceKey;
use App\Enums\UserRole;
use App\Filament\Concerns\FollowsAdminMode;
use App\Models\Tenant;
use App\Support\Settings;
use App\Tenancy\TenantConfig;
use App\Tenancy\TenantFeatures;
use BackedEnum;
use Filament\Actions\Action;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TagsInput;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
@@ -90,6 +93,12 @@ public function mount(): void
'bank_iban' => $tenant->bank_iban,
'bank_bic' => $tenant->bank_bic,
'tax_note' => $tenant->tax_note,
'mailbox_host' => $tenant->mailbox_host,
'mailbox_port' => $tenant->mailbox_port,
'mailbox_username' => $tenant->mailbox_username,
'mailbox_password' => $tenant->mailbox_password,
'mailbox_encryption' => $tenant->mailbox_encryption,
'mailbox_folder' => $tenant->mailbox_folder,
...$this->periodValues($tenant),
]);
}
@@ -172,6 +181,22 @@ public function form(Schema $schema): Schema
->maxLength(255)
->columnSpanFull(),
]),
Section::make('Portal-Postfach')
->description('Aus diesem Postfach werden die Buchungsmails der Portale gelesen, damit ein Termin sofort gesperrt wird. Leerer Server = ausgeschaltet. Das Passwort liegt verschlüsselt in der Datenbank.')
->columns(2)
->collapsed()
->visible(fn (): bool => app(TenantFeatures::class)->enabled(TenantServiceKey::PortalMail))
->schema([
TextInput::make('mailbox_host')->label('IMAP-Server')->maxLength(190),
TextInput::make('mailbox_port')->label('Port')->numeric()->integer()->placeholder('993'),
TextInput::make('mailbox_username')->label('Benutzer')->maxLength(190),
TextInput::make('mailbox_password')->label('Passwort')->password()->revealable()->autocomplete(false)->maxLength(190),
Select::make('mailbox_encryption')
->label('Verschlüsselung')
->options(['ssl' => 'SSL', 'tls' => 'TLS', 'starttls' => 'STARTTLS'])
->placeholder('SSL'),
TextInput::make('mailbox_folder')->label('Ordner')->placeholder('INBOX')->maxLength(190),
]),
Section::make('Fristen und Grenzen')
->description('Leer bedeutet: die Vorgabe des Systems gilt. Löschfristen und Bot-Schutz lassen sich verschärfen, aber nicht über die Vorgabe hinaus lockern.')
->columns(3)
@@ -212,6 +237,12 @@ public function save(): void
'bank_iban' => $data['bank_iban'] ?? null,
'bank_bic' => $data['bank_bic'] ?? null,
'tax_note' => $data['tax_note'] ?? null,
'mailbox_host' => $data['mailbox_host'] ?? null,
'mailbox_port' => filled($data['mailbox_port'] ?? null) ? (int) $data['mailbox_port'] : null,
'mailbox_username' => $data['mailbox_username'] ?? null,
'mailbox_password' => $data['mailbox_password'] ?? null,
'mailbox_encryption' => $data['mailbox_encryption'] ?? null,
'mailbox_folder' => $data['mailbox_folder'] ?? null,
...array_map(fn (mixed $value): ?int => filled($value) ? (int) $value : null, $this->periodInput($data)),
]);
+2 -2
View File
@@ -51,8 +51,8 @@ public function health(Request $request): JsonResponse
$mailbox = [
'configured' => MailboxReader::isConfigured(),
'ok' => ! MonitorChannels::mailboxIsStale(),
'last_success_at' => Cache::get(MailboxReader::LAST_SUCCESS_KEY),
'last_error' => Cache::get(MailboxReader::LAST_ERROR_KEY),
'last_success_at' => Cache::get(MailboxReader::key(MailboxReader::LAST_SUCCESS_KEY)),
'last_error' => Cache::get(MailboxReader::key(MailboxReader::LAST_ERROR_KEY)),
];
$ok = $channels->every(fn (array $channel): bool => $channel['ok']) && $mailbox['ok'];
+24
View File
@@ -21,6 +21,7 @@
'sender_name', 'sender_email',
'bank_account_holder', 'bank_iban', 'bank_bic', 'bank_name', 'tax_note',
'operating_mode', 'test_recipient', 'suspended_message',
'mailbox_host', 'mailbox_port', 'mailbox_encryption', 'mailbox_username', 'mailbox_password', 'mailbox_folder',
'deposit_due_days', 'review_request_after_days', 'guest_retention_years', 'retention_inquiry_months',
'retention_portal_email_excerpt_days', 'retention_attribution_months',
'spam_min_seconds', 'spam_per_ip_per_hour', 'spam_per_email_per_day', 'spam_open_requests_per_email', 'spam_max_links',
@@ -54,6 +55,7 @@ protected function casts(): array
'bank_bic' => 'encrypted',
'bank_name' => 'encrypted',
'tax_note' => 'encrypted',
'mailbox_password' => 'encrypted',
];
}
@@ -89,6 +91,28 @@ public function serviceUsages(): HasMany
return $this->hasMany(ServiceUsage::class);
}
/**
* The mailbox this landlord reads portal notifications from, or null when they have none. An empty
* host means the fast path is simply off for them.
*
* @return array{host: string, port: int, encryption: string, username: string, password: ?string, folder: string}|null
*/
public function mailbox(): ?array
{
if (blank($this->mailbox_host) || blank($this->mailbox_username)) {
return null;
}
return [
'host' => (string) $this->mailbox_host,
'port' => (int) ($this->mailbox_port ?: 993),
'encryption' => (string) ($this->mailbox_encryption ?: 'ssl'),
'username' => (string) $this->mailbox_username,
'password' => $this->mailbox_password,
'folder' => (string) ($this->mailbox_folder ?: 'INBOX'),
];
}
public function isLive(): bool
{
return $this->operating_mode === 'live';
+3 -1
View File
@@ -6,7 +6,9 @@
use App\Models\User;
/**
* Landlords are created and suspended by the operator. Deleting one is a later, separate step.
* Landlords are created and suspended by the operator. Deleting one is deliberately not an action in the
* panel: it removes data and files for good. It happens through `php artisan tenants:delete <slug>`, which
* writes an export first and asks before it acts.
*/
class TenantPolicy
{
+234
View File
@@ -0,0 +1,234 @@
<?php
namespace App\Tenancy;
use App\Models\Photo;
use App\Models\Tenant;
use App\Models\User;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Schema;
use RuntimeException;
use Spatie\MediaLibrary\MediaCollections\Models\Media;
use ZipArchive;
/**
* Hands a landlord their data back and removes them (A25). Everything of one landlord is reachable by
* `tenant_id`, so neither is a join across eight levels – it is a list of tables.
*/
class TenantArchive
{
/**
* Child rows first, so foreign keys allow the delete. The reverse order is the one in which the rows
* were assigned when tenancy was introduced.
*
* @var list<string>
*/
private const DELETE_ORDER = [
'floor_plans',
'channel_sync_logs',
'channel_tasks',
'portal_emails',
'payments',
'reviews',
'blocked_periods',
'bookings',
'special_offers',
'extras',
'seasons',
'amenities',
'photos',
'appearances',
'pages',
'notices',
'faqs',
'content_blocks',
'guests',
'channels',
'properties',
'site_domains',
'sites',
'tenant_services',
'service_usages',
'tenant_access_logs',
'tenant_user',
];
/**
* Writes every row and every uploaded file of this landlord into one zip file.
*
* @return string the path of the written archive
*/
public function export(Tenant $tenant, string $directory): string
{
File::ensureDirectoryExists($directory);
$path = rtrim($directory, '/\\').DIRECTORY_SEPARATOR.'mandant-'.$tenant->slug.'-'.now()->format('Ymd-His').'.zip';
$zip = new ZipArchive;
if ($zip->open($path, ZipArchive::CREATE | ZipArchive::OVERWRITE) !== true) {
throw new RuntimeException('Archiv konnte nicht angelegt werden: '.$path);
}
$zip->addFromString('mandant.json', (string) json_encode($tenant->toArray(), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
foreach ($this->tables() as $table) {
$rows = $this->rowsOf($table, $tenant);
$zip->addFromString(
'daten/'.$table.'.json',
(string) json_encode($rows, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
);
}
$zip->addFromString(
'daten/benutzer.json',
(string) json_encode($this->usersOf($tenant), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
);
$this->addFiles($zip, $tenant);
$zip->close();
return $path;
}
/**
* Who worked for this landlord, with their role. Deliberately without password hashes and without the
* two-factor secrets: the export is handed out, and those would be worth stealing.
*
* @return list<array{id: int, name: string, email: string, role: ?string, weitere_mandanten: int}>
*/
public function usersOf(Tenant $tenant): array
{
return User::query()
->whereHas('tenants', fn ($query) => $query->where('tenants.id', $tenant->id))
->withCount('tenants')
->get()
->map(fn (User $user): array => [
'id' => $user->id,
'name' => $user->name,
'email' => $user->email,
'role' => $user->roleOn($tenant->id)?->value,
'weitere_mandanten' => max(0, $user->tenants_count - 1),
])
->all();
}
/**
* Removes the landlord and everything that belongs to them, files included. The landlord row goes last.
*
* @return array<string, int> how many rows were removed per table
*/
public function delete(Tenant $tenant): array
{
$this->deleteFiles($tenant);
$orphans = $this->accountsLosingTheirLastLandlord($tenant);
$removed = [];
DB::transaction(function () use ($tenant, $orphans, &$removed): void {
foreach (self::DELETE_ORDER as $table) {
if (! $this->hasTenantColumn($table)) {
continue;
}
$count = DB::table($table)->where('tenant_id', $tenant->id)->delete();
if ($count > 0) {
$removed[$table] = $count;
}
}
if ($orphans !== []) {
$removed['users'] = User::query()->whereKey($orphans)->delete();
}
$tenant->delete();
});
return $removed;
}
/**
* Accounts that belonged to this landlord only. They are removed with them – an account that can reach
* nothing is personal data without a purpose. An operator keeps their account, and so does anybody who
* still works for another landlord.
*
* @return list<int>
*/
private function accountsLosingTheirLastLandlord(Tenant $tenant): array
{
return User::query()
->where('is_operator', false)
->whereHas('tenants', fn ($query) => $query->where('tenants.id', $tenant->id))
->withCount('tenants')
->get()
->filter(fn (User $user): bool => $user->tenants_count === 1)
->pluck('id')
->all();
}
/**
* Tables carrying a tenant_id, in a stable order.
*
* @return list<string>
*/
public function tables(): array
{
return array_values(array_filter(self::DELETE_ORDER, fn (string $table): bool => $this->hasTenantColumn($table)));
}
/**
* @return list<array<string, mixed>>
*/
private function rowsOf(string $table, Tenant $tenant): array
{
return array_map(
fn (object $row): array => (array) $row,
DB::table($table)->where('tenant_id', $tenant->id)->get()->all(),
);
}
/**
* Photos keep their files through Spatie's media library; they hang off the photo, not off the landlord,
* so they are collected through the photos of this landlord.
*/
private function addFiles(ZipArchive $zip, Tenant $tenant): void
{
foreach ($this->mediaOf($tenant) as $media) {
$path = $media->getPath();
if (is_string($path) && File::exists($path)) {
$zip->addFile($path, 'dateien/'.$media->id.'-'.$media->file_name);
}
}
}
private function deleteFiles(Tenant $tenant): void
{
foreach ($this->mediaOf($tenant) as $media) {
$media->delete(); // removes the stored file as well
}
}
/**
* @return Collection<int, Media>
*/
private function mediaOf(Tenant $tenant): Collection
{
return app(TenantContext::class)->run(
$tenant,
fn () => Photo::query()->with('media')->get()->flatMap(fn (Photo $photo) => $photo->media),
);
}
private function hasTenantColumn(string $table): bool
{
static $known = [];
return $known[$table] ??= Schema::hasTable($table)
&& Schema::hasColumn($table, 'tenant_id');
}
}
+18 -1
View File
@@ -37,6 +37,23 @@ public static function forLegacyLandlord(array $settings = [], bool $encryptBank
];
}
/**
* The mailbox the single-landlord installation used, taken from the .env for a raw database write.
*
* @return array<string, mixed>
*/
public static function mailboxFromConfig(): array
{
return [
'mailbox_host' => config('fewo.mailbox.host'),
'mailbox_port' => config('fewo.mailbox.port'),
'mailbox_encryption' => config('fewo.mailbox.encryption'),
'mailbox_username' => config('fewo.mailbox.username'),
'mailbox_password' => self::bank(config('fewo.mailbox.password'), true),
'mailbox_folder' => config('fewo.mailbox.folder'),
];
}
/**
* The value of the installation, not the one a landlord may already have laid over the configuration.
*/
@@ -53,7 +70,7 @@ private static function setting(array $settings, string $key): ?string
return filled($settings[$key] ?? null) ? (string) $settings[$key] : null;
}
private static function bank(mixed $value, bool $encrypt): ?string
public static function bank(mixed $value, bool $encrypt): ?string
{
if (blank($value)) {
return null;
+57
View File
@@ -0,0 +1,57 @@
<?php
namespace App\Tenancy;
use App\Models\Tenant;
use Closure;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Throwable;
/**
* Runs background work once per landlord, with that landlord current. Everything the scheduler does –
* expiring holds, importing portals, writing reminders – acts on one landlord's data and sends mail with
* one landlord's sender, so it has to be told which one.
*
* Without this, a run with several landlords sees no landlord at all: queries fall back to unfiltered and
* mail falls back to the .env sender, which would send one landlord's reminders with another one's address.
*
* A landlord whose run fails does not stop the others – the next one still gets its turn.
*/
class TenantRunner
{
/**
* @param Closure(Tenant): void $callback
* @return int how many landlords ran without an error
*/
public function each(Closure $callback, bool $onlyActive = true): int
{
$context = app(TenantContext::class);
$succeeded = 0;
foreach ($this->tenants($onlyActive) as $tenant) {
try {
$context->run($tenant, fn () => $callback($tenant));
$succeeded++;
} catch (Throwable $exception) {
Log::error('Lauf für Mandant '.$tenant->slug.' fehlgeschlagen: '.$exception->getMessage(), [
'tenant_id' => $tenant->id,
'exception' => $exception,
]);
}
}
return $succeeded;
}
/**
* @return Collection<int, Tenant>
*/
public function tenants(bool $onlyActive = true): Collection
{
return Tenant::query()
->when($onlyActive, fn ($query) => $query->where('is_active', true))
->orderBy('id')
->get();
}
}
@@ -0,0 +1,43 @@
<?php
use App\Tenancy\TenantDefaults;
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
/**
* Each landlord reads the portals' booking notifications from their own mailbox. An empty host means
* the fast path is off for that landlord. The password is encrypted with APP_KEY like the bank details.
*/
public function up(): void
{
Schema::table('tenants', function (Blueprint $table) {
$table->string('mailbox_host')->nullable();
$table->unsignedSmallInteger('mailbox_port')->nullable();
$table->string('mailbox_encryption', 10)->nullable();
$table->string('mailbox_username')->nullable();
$table->text('mailbox_password')->nullable();
$table->string('mailbox_folder')->nullable();
});
// Whatever the single-landlord installation had in its .env belongs to Stommer.
$stommer = DB::table('tenants')->where('slug', 'stommer')->first();
if ($stommer !== null && filled(config('fewo.mailbox.host'))) {
DB::table('tenants')->where('id', $stommer->id)->update(TenantDefaults::mailboxFromConfig());
}
}
public function down(): void
{
Schema::table('tenants', function (Blueprint $table) {
$table->dropColumn([
'mailbox_host', 'mailbox_port', 'mailbox_encryption',
'mailbox_username', 'mailbox_password', 'mailbox_folder',
]);
});
}
};
+11 -5
View File
@@ -5,39 +5,45 @@
use App\Actions\RemindChannelTasks;
use App\Actions\RequestReviews;
use App\Actions\SendBookingReminders;
use App\Tenancy\TenantRunner;
use Illuminate\Support\Facades\Schedule;
/**
* Everything that acts on a landlord's data runs once per landlord (TenantRunner), so queries see the right
* rows and mail goes out with the right sender. Only the database backup stays global: one database, one dump.
*/
Schedule::command('bookings:expire-holds')->everyFiveMinutes()->withoutOverlapping();
Schedule::command('channels:sync')->everyFiveMinutes()->withoutOverlapping(10);
Schedule::command('channels:fetch-mail')->everyMinute()->withoutOverlapping(5);
Schedule::call(fn (MonitorChannels $monitorChannels) => $monitorChannels->handle())
Schedule::call(fn (TenantRunner $runner, MonitorChannels $monitorChannels) => $runner->each(fn () => $monitorChannels->handle()))
->name('channels:monitor')
->everyFifteenMinutes()
->withoutOverlapping();
Schedule::call(fn (RemindChannelTasks $remindChannelTasks) => $remindChannelTasks->handle())
Schedule::call(fn (TenantRunner $runner, RemindChannelTasks $remindChannelTasks) => $runner->each(fn () => $remindChannelTasks->handle()))
->name('channels:remind-tasks')
->everyFifteenMinutes()
->withoutOverlapping();
Schedule::call(fn (SendBookingReminders $sendBookingReminders) => $sendBookingReminders->handle())
Schedule::call(fn (TenantRunner $runner, SendBookingReminders $sendBookingReminders) => $runner->each(fn () => $sendBookingReminders->handle()))
->name('bookings:reminders')
->dailyAt('09:00')
->withoutOverlapping();
Schedule::call(fn (RequestReviews $requestReviews) => $requestReviews->handle())
Schedule::call(fn (TenantRunner $runner, RequestReviews $requestReviews) => $runner->each(fn () => $requestReviews->handle()))
->name('reviews:request')
->dailyAt('10:00')
->withoutOverlapping();
Schedule::call(fn (AnonymizeGuests $anonymizeGuests) => $anonymizeGuests->handle())
Schedule::call(fn (TenantRunner $runner, AnonymizeGuests $anonymizeGuests) => $runner->each(fn () => $anonymizeGuests->handle()))
->name('guests:anonymize')
->dailyAt('03:00')
->withoutOverlapping();
// One database, one dump – across all landlords (see MANDANTEN-PLAN §5).
Schedule::command('backup:database')
->name('backup:database')
->dailyAt('02:30')
+3 -1
View File
@@ -21,6 +21,7 @@
use App\Models\PortalEmail;
use App\Models\Property;
use App\Models\User;
use App\Support\Settings;
use Carbon\CarbonImmutable;
use Database\Seeders\PropertySeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
@@ -188,7 +189,8 @@ public function test_n8n_can_push_mails_with_a_signed_request(): void
public function test_mailbox_outage_is_alerted_once(): void
{
config(['fewo.mailbox.host' => 'imap.strato.de', 'fewo.mailbox.username' => 'fewo@stommer.de']);
// The mailbox belongs to the landlord now, not to the server's .env.
Settings::tenant()?->update(['mailbox_host' => 'imap.strato.de', 'mailbox_username' => 'fewo@stommer.de']);
$this->fewo->update(['settings' => ['email_senders' => 'fewo-direkt.de']]);
+171
View File
@@ -0,0 +1,171 @@
<?php
namespace Tests\Feature;
use App\Actions\ExpireReservations;
use App\Channels\Mail\MailboxReader;
use App\Mail\ReservationExpired;
use App\Models\Booking;
use App\Models\Channel;
use App\Models\Property;
use App\Models\Site;
use App\Models\Tenant;
use App\Tenancy\TenantContext;
use App\Tenancy\TenantRunner;
use Carbon\CarbonImmutable;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Tests\TestCase;
/**
* Phase 4: everything running in the background belongs to one landlord. Without a landlord the scheduler
* sees no landlord at all – queries stop filtering and mail falls back to the server's sender, which would
* send one landlord's reminders under another one's address.
*/
class TenantScheduleTest extends TestCase
{
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->travelTo(CarbonImmutable::parse('2026-11-01 09:00'));
Mail::fake();
}
public function test_the_runner_visits_every_active_landlord_with_that_landlord_current(): void
{
$first = Tenant::factory()->create(['name' => 'Erster']);
$second = Tenant::factory()->create(['name' => 'Zweiter']);
Tenant::factory()->create(['name' => 'Gesperrt', 'is_active' => false]);
$seen = [];
$succeeded = app(TenantRunner::class)->each(function (Tenant $tenant) use (&$seen): void {
$seen[] = [$tenant->id, app(TenantContext::class)->id()];
});
$this->assertSame(2, $succeeded);
$this->assertSame([[$first->id, $first->id], [$second->id, $second->id]], $seen);
$this->assertNull(app(TenantContext::class)->id(), 'Nach dem Lauf ist kein Mandant mehr gesetzt.');
}
public function test_a_failing_landlord_does_not_stop_the_others(): void
{
Tenant::factory()->create();
Tenant::factory()->create();
$visited = 0;
$succeeded = app(TenantRunner::class)->each(function () use (&$visited): void {
$visited++;
if ($visited === 1) {
throw new \RuntimeException('Postfach nicht erreichbar');
}
});
$this->assertSame(2, $visited);
$this->assertSame(1, $succeeded);
}
/**
* The test the plan asks for: a run for A must not write to B's guests, nor under B's sender.
*/
public function test_a_run_touches_only_its_own_landlord_and_uses_their_sender(): void
{
[$a, $bookingA] = $this->landlordWithExpiredHold('Nordhaus', 'nord@example.com', 'Absender Nord <nord@example.com>');
[$b, $bookingB] = $this->landlordWithExpiredHold('Südheim', 'sued@example.com', 'Absender Süd <sued@example.com>');
$senders = [];
app(TenantRunner::class)->each(function (Tenant $tenant) use (&$senders): void {
$senders[$tenant->name] = [config('mail.from.address'), config('fewo.owner.name')];
app(ExpireReservations::class)->handle();
});
$this->assertSame(['nord@example.com', 'Nordhaus'], $senders['Nordhaus']);
$this->assertSame(['sued@example.com', 'Südheim'], $senders['Südheim']);
// Each landlord is told about their own expired hold only.
Mail::assertSent(ReservationExpired::class, 2);
Mail::assertSent(ReservationExpired::class, fn (ReservationExpired $mail): bool => $mail->hasTo('nord@example.com'));
Mail::assertSent(ReservationExpired::class, fn (ReservationExpired $mail): bool => $mail->hasTo('sued@example.com'));
$this->assertSame('expired', $bookingA->fresh()->status->value);
$this->assertSame('expired', $bookingB->fresh()->status->value);
$this->assertNotSame($a->id, $b->id);
}
public function test_the_mailbox_belongs_to_the_landlord_and_is_unreadable_from_another_one(): void
{
$withBox = Tenant::factory()->create([
'mailbox_host' => 'imap.nord.example',
'mailbox_username' => 'post@nord.example',
'mailbox_password' => 'geheim',
]);
$without = Tenant::factory()->create();
app(TenantContext::class)->set($withBox);
$this->assertTrue(MailboxReader::isConfigured());
$this->assertSame('imap.nord.example', MailboxReader::configuration()['host']);
$this->assertSame('geheim', MailboxReader::configuration()['password']);
app(TenantContext::class)->set($without);
$this->assertFalse(MailboxReader::isConfigured(), 'Ein Mandant ohne Postfach sieht keines – auch nicht das fremde.');
$this->assertNull(MailboxReader::configuration());
// Stored encrypted, like the bank details.
$this->assertNotSame('geheim', DB::table('tenants')->where('id', $withBox->id)->value('mailbox_password'));
}
public function test_the_ical_token_of_one_landlord_does_not_serve_another_ones_occupancy(): void
{
$nord = $this->websiteFor(Tenant::factory()->create(['name' => 'Nordhaus']), 'nord.test');
$sued = $this->websiteFor(Tenant::factory()->create(['name' => 'Südheim']), 'sued.test');
$channel = app(TenantContext::class)->run($nord->tenant, fn (): Channel => Channel::factory()->create([
'property_id' => Property::factory()->create(['site_id' => $nord->id])->id,
]));
// On its own address the feed answers …
$this->get('http://nord.test'.route('channels.feed', ['token' => $channel->export_token], absolute: false))->assertOk();
// … on the other landlord's address it does not exist.
$this->get('http://sued.test'.route('channels.feed', ['token' => $channel->export_token], absolute: false))->assertNotFound();
$this->assertNotNull($sued);
}
/**
* @return array{Tenant, Booking}
*/
private function landlordWithExpiredHold(string $name, string $email, string $sender): array
{
$tenant = Tenant::factory()->create([
'name' => $name,
'owner_name' => $name,
'notification_emails' => $email,
'sender_email' => $email,
'sender_name' => 'Absender '.$name,
'operating_mode' => 'live',
]);
$booking = app(TenantContext::class)->run($tenant, fn (): Booking => Booking::factory()
->for(Property::factory()->create())
->reserved(now()->subHour())
->create());
return [$tenant, $booking];
}
private function websiteFor(Tenant $tenant, string $host): Site
{
return app(TenantContext::class)->run($tenant, fn (): Site => Site::factory()->create([
'tenant_id' => $tenant->id,
'name' => $tenant->name,
'domain' => $host,
'is_default' => false,
]));
}
}
+220
View File
@@ -0,0 +1,220 @@
<?php
namespace Tests\Feature;
use App\Enums\UserRole;
use App\Models\Amenity;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\Channel;
use App\Models\ContentBlock;
use App\Models\Extra;
use App\Models\Faq;
use App\Models\Guest;
use App\Models\Notice;
use App\Models\Page;
use App\Models\Payment;
use App\Models\Photo;
use App\Models\Property;
use App\Models\Review;
use App\Models\Season;
use App\Models\Site;
use App\Models\SpecialOffer;
use App\Models\Tenant;
use App\Models\User;
use App\Tenancy\TenantArchive;
use App\Tenancy\TenantContext;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\File;
use Tests\TestCase;
use ZipArchive;
/**
* Phase 5: the acceptance of the separation. Every area from A1 is filled for two landlords; then one is
* exported and deleted, and the other has to be complete – rows, files and booking numbers.
*
* This is the test that would notice if a new table ever forgot its tenant_id: such a table would neither
* be exported nor deleted, and its rows would outlive the landlord they belong to.
*/
class TenantSeparationTest extends TestCase
{
use RefreshDatabase;
public function test_every_area_of_a_landlord_is_exported_and_deleted_while_the_other_stays_whole(): void
{
$gone = $this->landlordWithEverything('Geht');
$stays = $this->landlordWithEverything('Bleibt');
$before = $this->census($stays);
$this->assertNotEmpty(array_filter($before), 'Der Aufbau muss jeden Bereich füllen.');
$archive = app(TenantArchive::class);
$directory = storage_path('framework/testing/tenant-export');
$path = $archive->export($gone, $directory);
$this->assertFileExists($path);
$this->assertExportHasOnly($path, $gone, $stays);
$archive->delete($gone);
$this->assertDatabaseMissing('tenants', ['id' => $gone->id]);
foreach ($archive->tables() as $table) {
$this->assertSame(
0,
DB::table($table)->where('tenant_id', $gone->id)->count(),
"In {$table} sind Zeilen des gelöschten Mandanten übrig.",
);
}
$this->assertSame($before, $this->census($stays), 'Der verbliebene Mandant hat sich verändert.');
// site_domains trägt keine tenant_id; die Hosts hängen über die Website am Mandanten. Bleibt hier
// eine Zeile übrig, zeigt ein Host auf eine gelöschte Website – schlimmstenfalls auf einen fremden.
$this->assertSame(0, DB::table('site_domains')->where('host', 'geht.test')->count(), 'Verwaister Host nach der Löschung.');
$this->assertSame(1, DB::table('site_domains')->where('host', 'bleibt.test')->count());
File::deleteDirectory($directory);
}
public function test_a_deleted_landlord_frees_their_booking_numbers_without_touching_the_others(): void
{
$gone = $this->landlordWithEverything('Geht');
$stays = $this->landlordWithEverything('Bleibt');
$reference = app(TenantContext::class)->run($stays, fn (): string => Booking::query()->value('reference'));
app(TenantArchive::class)->delete($gone);
app(TenantContext::class)->run($stays, function () use ($reference): void {
$this->assertSame($reference, Booking::query()->value('reference'));
$this->assertSame(1, Booking::query()->count());
});
}
public function test_accounts_of_the_deleted_landlord_go_with_them_unless_they_serve_somebody_else(): void
{
$gone = $this->landlordWithEverything('Geht');
$stays = $this->landlordWithEverything('Bleibt');
$onlyTheirs = User::factory()->create(['email' => 'nur-dort@example.com']);
$onlyTheirs->tenants()->sync([$gone->id => ['role' => UserRole::Admin->value]]);
$shared = User::factory()->create(['email' => 'beide@example.com']);
$shared->tenants()->sync([
$gone->id => ['role' => UserRole::Rentals->value],
$stays->id => ['role' => UserRole::Rentals->value],
]);
$operator = User::factory()->create(['email' => 'betrieb@example.com']);
$operator->tenants()->sync([$gone->id => ['role' => UserRole::Admin->value]]);
$operator->forceFill(['is_operator' => true])->saveQuietly();
app(TenantArchive::class)->delete($gone);
$this->assertDatabaseMissing('users', ['email' => 'nur-dort@example.com']);
$this->assertDatabaseHas('users', ['email' => 'beide@example.com']);
$this->assertDatabaseHas('users', ['email' => 'betrieb@example.com']);
$this->assertSame([$stays->id], $shared->fresh()->tenants()->pluck('tenants.id')->all());
}
public function test_the_export_names_the_accounts_but_not_their_passwords(): void
{
$tenant = $this->landlordWithEverything('Geht');
$user = User::factory()->create(['email' => 'wirt@example.com', 'name' => 'Wirt']);
$user->tenants()->sync([$tenant->id => ['role' => UserRole::Admin->value]]);
$exported = app(TenantArchive::class)->usersOf($tenant);
$this->assertSame(['wirt@example.com'], array_column($exported, 'email'));
$this->assertSame('admin', $exported[0]['role']);
$this->assertArrayNotHasKey('password', $exported[0]);
$this->assertStringNotContainsString($user->password, (string) json_encode($exported));
}
/**
* The archive of one landlord must not carry a single row of the other.
*/
private function assertExportHasOnly(string $path, Tenant $exported, Tenant $other): void
{
$zip = new ZipArchive;
$this->assertTrue($zip->open($path) === true);
$seen = 0;
for ($i = 0; $i < $zip->numFiles; $i++) {
$name = (string) $zip->getNameIndex($i);
if (! str_starts_with($name, 'daten/')) {
continue;
}
$rows = json_decode((string) $zip->getFromIndex($i), true);
$this->assertIsArray($rows);
foreach ($rows as $row) {
$seen++;
$this->assertSame($exported->id, $row['tenant_id'], "Fremde Zeile in {$name}.");
$this->assertNotSame($other->id, $row['tenant_id']);
}
}
$zip->close();
$this->assertGreaterThan(0, $seen, 'Das Archiv enthält keine Daten.');
}
/**
* How many rows this landlord has per table – the yardstick for "unchanged".
*
* @return array<string, int>
*/
private function census(Tenant $tenant): array
{
$counts = [];
foreach (app(TenantArchive::class)->tables() as $table) {
$counts[$table] = DB::table($table)->where('tenant_id', $tenant->id)->count();
}
return $counts;
}
/**
* One landlord with at least one row in every area of A1.
*/
private function landlordWithEverything(string $name): Tenant
{
$tenant = Tenant::factory()->create(['name' => $name]);
app(TenantContext::class)->run($tenant, function () use ($name): void {
$site = Site::factory()->create([
'name' => $name,
'domain' => mb_strtolower($name).'.test',
'is_default' => false,
]);
$property = Property::factory()->create(['site_id' => $site->id]);
Page::factory()->create(['site_id' => $site->id, 'slug' => Page::HOME, 'sections' => []]);
Season::factory()->create(['property_id' => $property->id]);
Extra::factory()->create(['property_id' => $property->id]);
Amenity::factory()->create(['property_id' => $property->id]);
SpecialOffer::factory()->create(['property_id' => $property->id]);
Photo::factory()->create(['property_id' => $property->id]);
Faq::factory()->create();
Notice::factory()->create();
ContentBlock::query()->create(['key' => 'legal.imprint', 'value' => 'Impressum '.$name]);
$guest = Guest::factory()->create();
$booking = Booking::factory()->for($property)->create(['guest_id' => $guest->id]);
Payment::factory()->create(['booking_id' => $booking->id]);
Review::factory()->create(['booking_id' => $booking->id, 'property_id' => $property->id]);
$channel = Channel::factory()->create(['property_id' => $property->id]);
BlockedPeriod::factory()->create(['property_id' => $property->id, 'channel_id' => $channel->id]);
});
return $tenant;
}
}