Compare commits

..
Author SHA1 Message Date
LarsandClaude Opus 5.5 3bcfc09417 Pakete 8, 5 und 6: Beträge und Zahlungen, Ändern und Stornieren, A6 im Vorgang
Deploy FeWo mit PipelineManager / deploy (push) Successful in 4m44s
- Paket 8: Zahlungsarten (Gast an uns, laut Portal, Auszahlung, Erstattung),
  Portalbeträge als Angaben mit Quelle, Übersicht nach Zuständigkeit (R09).
- Paket 5: Ändern mit Folgenvorschau, vereinbart oder dem Gast vorgeschlagen
  (signierter Link), ein Stornoweg mit Grund und Erstattung, Portalstorno erst
  nach Bestätigung.
- Paket 6: eigene Nutzung, Besuch und Sperre als Vorgang mit Kurabgabe und
  Aufenthaltsbestätigung; Bestandsübernahme der Sperren mit identischem Export.
- Wirksame Einstellungen (Expertenansicht), Abnahmekatalog T01–T14, Ergebnis-,
  Abnahme- und Konfigurationsdokument.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 22:16:47 +01:00
LarsandClaude Opus 5.5 33f8f899d6 Prozessarchitektur 0.10
Deploy FeWo mit PipelineManager / deploy (push) Successful in 3m57s
Neue hierarchische Struktur der fachlichen Sollbeschreibung (README, Prozesslandkarte,
Buchungsarchetypen, Abwicklungsprofile, Entscheidungen, Offene Fragen, Querschnitt,
Szenarien, V01/V02, Referenzen); die Fassung 0.9 bleibt in der Git-Historie.
Obsidian-Fensterzustand (workspace.json) wird nicht mehr versioniert.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 21:11:54 +01:00
LarsandClaude Opus 5.5 0c10880e4f Testbetrieb: eine Schranke fuer jede ausgehende E-Mail
Deploy FeWo mit PipelineManager / deploy (push) Failing after 3m10s
EnforceMailTestMode prueft jede Mail unmittelbar vor dem Versand (MessageSending,
jeder Mailer): im Testbetrieb gehen An/Cc/Bcc nur an die Testadresse, ohne
Testadresse wird nichts versendet; der Modus wird je Mail frisch gelesen.
Ersetzt alwaysTo am Standard-Mailer. Tests inkl. Pruefung, dass kein Code am
Mailer vorbei versendet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 21:03:24 +01:00
LarsandClaude Opus 5.5 ac9d20b812 Ein Eingang fuer alle Kanaele (Paket 4, Prozessarchitektur v0.10)
Portalbuchungen und -anfragen aus Kalender und Mail werden ueber PortalIntake
zum Vorgang (nur bei sicherer Erkennung), Dubletten ueber Buchungsnummer,
gleiches Portal mit gleichen Naechten und Spiegelung; Unsicheres wird geklaert.
Portalstorno und -aenderung als Aufgabe am Vorgang ohne stille Stornierung.
Schalter je Kanal (Aus als Standard, Beobachten, Anlegen, Anlegen + weiter),
Eingangsprotokoll, Bestandsuebernahme mit Vorschau/Bericht/Ruecknahme,
Sperrnachweis in drei Stufen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 20:53:35 +01:00
170 changed files with 6649 additions and 5800 deletions

No files matched your search

+3
View File
@@ -34,3 +34,6 @@ Thumbs.db
/scripts/deploy.*.env
!/scripts/deploy.example.env
storage/app/private/exports/
# Obsidian: persönlicher Fensterzustand des Editors
docs/Prozessarchitektur/.obsidian/workspace.json
+1 -1
View File
@@ -17,7 +17,7 @@ # Ferienwohnung Stommer
- Website = theme system (`docs/THEMES.md`): themes live in `resources/themes/<key>` (theme.json, theme.css, theme.js, views); views resolve via the `theme::` namespace (theme → parent → base `ostsee-licht`). Pages are lists of sections (`app/Themes/Sections`, catalogue in `config/themes.php`); seasonal `Appearance`s override tokens/texts/hero photo/photos per section (stable `data.id` per placed section) and sections can be limited to appearances. Theme views use only token colour classes (`bg-accent`, `text-muted`, …). New designs are **additional** themes: `php artisan themes:make <key>`, `themes:check`, `themes:preview` – never edit `ostsee-licht` for a new design; authoring rules in `docs/THEME-ERSTELLUNG.md`. Resolve `Theme` lazily (`app(Theme::class)`), never in constructors – middleware `ResolveTheme` replaces it per request.
- Operations (environments, Strato access, server .env, admin accounts, 2FA, known pitfalls): `docs/BETRIEB.md` – read it before touching a server. Admin accounts: `php artisan users:create`; 2FA (Filament app authentication) is mandatory for every account. Admin modes (`App\Enums\AdminMode`: simple/expert per user, user menu switch) only shape the menu via the `FollowsAdminMode` trait on every resource/page (simple menu = `AdminMode::SIMPLE_NAVIGATION`); permissions stay with roles/policies. New admin resources must use `FollowsAdminMode`.
- Deployment: `scripts/deploy.sh <env> setup|deploy [ref]|rollback|releases|artisan` (atomic releases on Strato, docs/DEPLOYMENT.md; the server keeps only the active release because of Strato's file quota – history = Git tags `deploy/<env>/<timestamp>`); CI `.gitea/workflows/deploy.yml`. Production has no dev packages (no factories/Faker) – production seeding via `ProductionSeeder`.
- Strato specifics: `public/index.php` strips the internal `/releases/<v>/public` prefix from `REQUEST_URI` (signed URLs); `URL::forceRootUrl(APP_URL)` outside local/testing; mail routing: `App\Support\Settings` (admin page System › Betrieb, stored on the tenant) – test mode (default) sends every mail to the test recipient only, live delivers normally; `FEWO_MAIL_REDIRECT_TO` is a hard override. Landlord data, bank, addresses and periods are columns of `tenants`: `App\Tenancy\TenantConfig` lays them over `config('fewo.*')` and `mail.from` whenever the tenant context changes, so views and mails keep reading the config keys. Send notifications to `Settings::notificationRecipients()` (never `config('fewo.notification_email')` directly). Findings detected repeatedly (e.g. by the 5-minute sync) go through `AppSupportInbox` (admin Postfach, fingerprint per tenant, repeated only per the tenant's `reminder_interval_days`), never straight to mail; daily/weekly summaries: `SendDigests` + `DigestReport` (sections `DigestSection`). Retention periods and bot-protection counters can only be tightened against the `.env` baseline. The booking form is protected against bots (`config('fewo.spam')`: honeypot, time trap, rate limits, max open holds per e-mail) – tests that submit it instantly set `fewo.spam.min_seconds` to 0.
- Strato specifics: `public/index.php` strips the internal `/releases/<v>/public` prefix from `REQUEST_URI` (signed URLs); `URL::forceRootUrl(APP_URL)` outside local/testing; mail routing: `App\Support\Settings` (admin page System › Betrieb, stored on the tenant) – test mode (default) sends every mail to the test recipient only, live delivers normally; `FEWO_MAIL_REDIRECT_TO` is a hard override. The one gate is `App\Listeners\EnforceMailTestMode` (MessageSending, every mailer; no test address in test mode = nothing is sent) – never send mail around Laravel's mailer (no direct transports, `mail()`, own SMTP; `MailTestModeGateTest` checks this). Landlord data, bank, addresses and periods are columns of `tenants`: `App\Tenancy\TenantConfig` lays them over `config('fewo.*')` and `mail.from` whenever the tenant context changes, so views and mails keep reading the config keys. Send notifications to `Settings::notificationRecipients()` (never `config('fewo.notification_email')` directly). Findings detected repeatedly (e.g. by the 5-minute sync) go through `AppSupportInbox` (admin Postfach, fingerprint per tenant, repeated only per the tenant's `reminder_interval_days`), never straight to mail; daily/weekly summaries: `SendDigests` + `DigestReport` (sections `DigestSection`). Retention periods and bot-protection counters can only be tightened against the `.env` baseline. The booking form is protected against bots (`config('fewo.spam')`: honeypot, time trap, rate limits, max open holds per e-mail) – tests that submit it instantly set `fewo.spam.min_seconds` to 0.
- Vite fonts plugin is removed on purpose (corporate proxy breaks remote font downloads, and fonts must be self-hosted for GDPR).
- PHP/Composer on this machine: winget package dir `%LOCALAPPDATA%\Microsoft\WinGet\Packages\PHP.PHP.8.4_*` (Composer as `composer\composer.phar` there).
- Git remote: Gitea `https://gitea.stommer.de/Lars/fewo-stommer.git`, branch `main`.
+81 -17
View File
@@ -5,11 +5,13 @@
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\Responsibility;
use App\Exceptions\ReservationException;
use App\Mail\BookingCancelled;
use App\Mail\CancellationRequested;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Process\CaseLog;
use App\Support\CancellationCost;
use App\Support\Money;
use App\Support\Settings;
@@ -19,45 +21,53 @@
use Throwable;
/**
* The landlord cancels a binding booking. The dates are free again; the guest and the landlord are informed by mail
* (the guest mail can be switched off, e.g. when the guest cancelled by phone and was told already) and a task for
* the cancellation costs is created. Open cancellation requests of the guest are completed.
* The one way to cancel a binding booking (package 5). Own bookings: the dates are free again; the guest and the
* landlord are informed by e-mail – the guest's e-mail can be switched off, e.g. when the guest cancelled by phone –, the
* cancellation is recorded with who initiated it, why and who entered it, a task for the cancellation costs and – when
* the guest paid us more than the costs – a refund task are created. Open cancellation requests of the guest are done.
*
* Bookings binding on a portal (A3–A5) are cancelled where the contract was made: here the cancellation is only
* requested (task "Stornierung im Portal veranlassen bzw. prüfen", the dates stay occupied) until somebody confirms that
* it is effective on the portal ({@see confirmOnPortal()}) – nothing is released silently.
*/
class CancelBooking
{
public const INITIATORS = ['guest' => 'vom Gast', 'landlord' => 'vom Vermieter', 'portal' => 'über das Portal'];
/**
* @return bool whether the guest has been informed (true as well when no mail was wanted; false when it failed)
*
* @throws ReservationException
*/
public function handle(Booking $booking, bool $notifyGuest = true, bool $costsTask = true, string $by = 'Verwaltung', string $initiatedBy = 'landlord'): bool
public function handle(Booking $booking, bool $notifyGuest = true, bool $costsTask = true, string $by = 'Verwaltung', string $initiatedBy = 'landlord', ?string $reason = null, bool $confirmedOnPortal = false): bool
{
if ($booking->caseType()->isExternallyBinding() && ! $confirmedOnPortal) {
$this->requestOnPortal($booking, $by, $initiatedBy, $reason);
return true;
}
if ($notifyGuest && blank($booking->guest?->email)) {
throw new ReservationException('Der Gast hat keine E-Mail-Adresse – bitte ohne Mail an den Gast stornieren oder die Adresse ergänzen.');
}
DB::transaction(function () use ($booking, $costsTask, $by, $initiatedBy): void {
DB::transaction(function () use ($booking, $costsTask, $by, $initiatedBy, $reason): void {
$booking->lockForTransition();
if (! in_array($booking->status, BookingStatus::occupying(), true)) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'storniert');
}
$booking->update(['status' => BookingStatus::Cancelled, 'cancelled_at' => now()]);
app(RecordCancellation::class)->handle($booking, $initiatedBy);
$booking->update(['status' => BookingStatus::Cancelled, 'cancelled_at' => now(), 'portal_cancellation_requested_at' => null]);
app(RecordCancellation::class)->handle($booking, $initiatedBy)->update(['reason' => $reason, 'recorded_by' => $by]);
if ($booking->caseType()->isExternallyBinding()) {
// The contract was made on the portal: the cancellation has to happen (or be checked) there as well.
BookingTask::query()->firstOrCreate(['booking_id' => $booking->id, 'kind' => BookingTaskKind::PortalCancellation], [
'status' => BookingTaskStatus::Open,
'due_on' => today(),
'note' => 'Stornierung auch im Portal „'.($booking->processChannel()?->name ?? 'Portal').'“ veranlassen bzw. prüfen, ob sie dort wirksam ist.',
]);
}
BookingTask::query()->where('booking_id', $booking->id)->where('kind', BookingTaskKind::CancellationRequest)->where('status', BookingTaskStatus::Open)
BookingTask::query()->where('booking_id', $booking->id)
->whereIn('kind', [BookingTaskKind::CancellationRequest, BookingTaskKind::PortalCancellation, BookingTaskKind::PortalCancellationReported])
->where('status', BookingTaskStatus::Open)
->update(['status' => BookingTaskStatus::Done, 'completed_by' => $by, 'completed_at' => now()]);
$this->refundTask($booking);
if ($costsTask) {
$cost = CancellationCost::calculate($booking);
BookingTask::query()->firstOrCreate(['booking_id' => $booking->id, 'kind' => BookingTaskKind::CancellationFee], [
@@ -73,6 +83,60 @@ public function handle(Booking $booking, bool $notifyGuest = true, bool $costsTa
return $this->notify($booking, $notifyGuest);
}
/**
* A booking binding on a portal was cancelled there (the landlord saw it on the portal, or the portal reported it):
* now the case is cancelled as well. The portal informs the guest; costs are a task only when we collect the money.
*
* @throws ReservationException
*/
public function confirmOnPortal(Booking $booking, string $by, string $initiatedBy = 'portal', ?string $reason = null): bool
{
return $this->handle($booking, notifyGuest: false, costsTask: $booking->process()->payments() === Responsibility::Landlord, by: $by, initiatedBy: $initiatedBy, reason: $reason, confirmedOnPortal: true);
}
/**
* @throws ReservationException
*/
private function requestOnPortal(Booking $booking, string $by, string $initiatedBy, ?string $reason): void
{
DB::transaction(function () use ($booking, $by, $initiatedBy, $reason): void {
$booking->lockForTransition();
if (! in_array($booking->status, BookingStatus::occupying(), true)) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'storniert');
}
$portal = $booking->processChannel()?->name ?? 'Portal';
$booking->update(['portal_cancellation_requested_at' => now()]);
BookingTask::query()->updateOrCreate(['booking_id' => $booking->id, 'kind' => BookingTaskKind::PortalCancellation], [
'tenant_id' => $booking->tenant_id, 'status' => BookingTaskStatus::Open, 'due_on' => today(), 'completed_by' => null, 'completed_at' => null,
'note' => 'Stornierung im Portal „'.$portal.'“ veranlassen und prüfen, ob sie dort wirksam ist. Erst dann „Stornierung bestätigen“ – bis dahin bleibt der Zeitraum belegt.',
]);
CaseLog::record($booking, 'status', 'Stornierung beim Portal '.$portal.' veranlasst ('.(self::INITIATORS[$initiatedBy] ?? $initiatedBy).') – der Vorgang bleibt gebucht, bis sie bestätigt ist', $reason, actor: $by);
});
}
/**
* When the guest paid us more than the cancellation costs, the difference is a refund to check.
*/
private function refundTask(Booking $booking): void
{
if ($booking->process()->payments() !== Responsibility::Landlord || $booking->paidToUs() <= 0) {
return;
}
$cost = CancellationCost::calculate($booking);
$fee = $cost['fee'] ?? null;
$paid = $booking->paidToUs();
if ($fee !== null && $paid <= $fee) {
return;
}
BookingTask::query()->updateOrCreate(['booking_id' => $booking->id, 'kind' => BookingTaskKind::RefundCheck], [
'tenant_id' => $booking->tenant_id, 'status' => BookingTaskStatus::Open, 'due_on' => today(), 'completed_by' => null, 'completed_at' => null,
'note' => 'Bezahlt: '.Money::format($paid).($fee !== null ? ' · Stornokosten laut Regel: '.Money::format($fee).' · zu erstatten: '.Money::format($paid - $fee) : ' · Stornokosten von Hand festlegen, den Rest erstatten').'. Erstattung als Zahlung „Erstattung an den Gast“ erfassen.',
]);
}
private function notify(Booking $booking, bool $notifyGuest): bool
{
$informed = true;
+480
View File
@@ -0,0 +1,480 @@
<?php
namespace App\Actions;
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\ChangeBasis;
use App\Enums\ChangeStatus;
use App\Enums\QuoteLineType;
use App\Exceptions\ReservationException;
use App\Mail\BookingChanged;
use App\Mail\ChangeProposed;
use App\Models\Booking;
use App\Models\BookingChange;
use App\Models\BookingTask;
use App\Models\Channel;
use App\Pricing\PortalPrice;
use App\Pricing\PriceCalculator;
use App\Pricing\PriceQuote;
use App\Pricing\PrivateStayPrice;
use App\Pricing\QuoteException;
use App\Pricing\QuoteLine;
use App\Pricing\StayRequest;
use App\Process\CaseLog;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\URL;
use Throwable;
/**
* Changes a booking after it became binding (package 5, UMSETZUNGSPLAN §4.6): dates, length of stay, number of guests,
* services and price. Before anything changes the consequences are put together – calendar and portals, price and its
* origin, payment plan, refund or additional payment, confirmation – and the person confirms them.
*
* Two ways, kept strictly apart:
* - **agreed**: the change was already agreed with the guest (phone, e-mail, in person, on the portal); it takes effect
* at once and the case keeps who asked, why, from when and on which basis. An updated confirmation only informs the
* guest – it is not taken as the guest's consent.
* - **proposed**: the guest still has to agree; nothing changes until the guest accepts through the signed link.
*
* Own bookings get their price recalculated (kept adjustments, or an agreed price); bookings binding on a portal take the
* portal's new total; internal cases (A6) keep their agreed rent and recalculate services and tourist tax.
*/
class ChangeBooking
{
public const REQUESTED_BY = ['guest', 'landlord', 'portal'];
public function __construct(
private PriceCalculator $calculator,
private PrivateStayPrice $privateStay,
private AvailabilityChecker $availability,
private PortalPrice $portalPrice,
private RecordPayment $payments,
) {}
/**
* The consequences of a change, without changing anything.
*
* @param array{arrival?: ?string, departure?: ?string, guests?: ?int, extras?: ?array<int, int>, portal_total?: ?int, agreed_total?: ?int, agreed_total_label?: ?string, rent?: ?int, tourist_tax_persons?: ?int} $changes
* @return array{errors: list<string>, before: array<string, mixed>, after: array<string, mixed>, summary: list<string>, calendar: list<string>, portals: list<string>, price: array{before: ?int, after: ?int, difference: ?int, source: string}, payment: list<string>, refund: int, confirmation: bool}
*/
public function preview(Booking $booking, array $changes): array
{
$booking->loadMissing(['property', 'payments', 'guest']);
$errors = [];
$before = self::snapshot($booking);
$arrival = CarbonImmutable::parse($changes['arrival'] ?? $booking->arrival);
$departure = CarbonImmutable::parse($changes['departure'] ?? $booking->departure);
$guests = array_key_exists('guests', $changes) && filled($changes['guests']) ? (int) $changes['guests'] : $booking->guests;
$extras = array_key_exists('extras', $changes) && is_array($changes['extras']) ? array_filter(array_map('intval', $changes['extras'])) : (array) ($booking->extras ?? []);
if ($departure->lessThanOrEqualTo($arrival)) {
$errors[] = 'Die Abreise muss nach der Anreise liegen.';
} elseif (! $this->availability->isAvailable($booking->property, $arrival, $departure, ignore: $booking)) {
$errors[] = 'Der neue Zeitraum ist nicht frei.';
}
if ($guests !== null && $guests > $booking->property->max_guests) {
$errors[] = 'Höchstens '.$booking->property->max_guests.' Personen.';
}
[$quote, $source, $priceError] = $departure->greaterThan($arrival) ? $this->price($booking, $changes, $arrival, $departure, $guests, $extras) : [null, '–', null];
if ($priceError !== null) {
$errors[] = $priceError;
}
$paid = $booking->paidAmount();
$total = $quote !== null ? $quote['total'] : $booking->total;
$depositPaid = $booking->deposit !== null && $paid >= $booking->deposit && $paid > 0;
$deposit = $quote === null ? $booking->deposit : ($depositPaid ? $booking->deposit : ($quote['deposit'] ?? $booking->deposit));
$after = [
'arrival' => $arrival->toDateString(), 'departure' => $departure->toDateString(), 'guests' => $guests, 'extras' => $extras,
'quote' => $quote['quote'] ?? $booking->quote, 'total' => $total, 'deposit' => $deposit,
'balance_due_on' => $quote['balance_due_on'] ?? $booking->balance_due_on?->toDateString(),
'rent' => $changes['rent'] ?? null, 'tourist_tax_persons' => array_key_exists('tourist_tax_persons', $changes) ? $changes['tourist_tax_persons'] : $booking->tourist_tax_persons,
];
[$calendar, $portals] = $this->calendarConsequences($booking, $arrival, $departure);
$difference = $total !== null && $booking->total !== null ? $total - $booking->total : null;
$refund = $total !== null ? max(0, $paid - $total) : 0;
$payment = array_values(array_filter([
$booking->wantsPaymentTasks() || ($total !== null && $total > 0 && $booking->process()->payments()->value === 'landlord' && ! $booking->isInternal()) ? 'Bezahlt bisher: '.Money::format($paid).' · danach offen: '.Money::format(max(0, (int) $total - $paid)) : null,
$refund > 0 ? 'Der Gast hat mehr bezahlt als der neue Preis: '.Money::format($refund).' zu erstatten (Aufgabe wird angelegt).' : null,
$depositPaid ? 'Die Anzahlung ist bezahlt und bleibt unverändert.' : null,
$after['balance_due_on'] !== ($booking->balance_due_on?->toDateString()) && $after['balance_due_on'] !== null && ! $booking->isInternal() ? 'Restzahlung neu fällig am '.CarbonImmutable::parse($after['balance_due_on'])->format('d.m.Y').'.' : null,
$booking->process()->payments()->value === 'portal' ? 'Die Zahlung läuft weiter über das Portal.' : null,
]));
return [
'errors' => $errors,
'before' => $before,
'after' => $after,
'summary' => self::summary($before, $after),
'calendar' => $calendar,
'portals' => $portals,
'price' => ['before' => $booking->total, 'after' => $total, 'difference' => $difference, 'source' => $source],
'payment' => $payment,
'refund' => $refund,
'confirmation' => ! $booking->isInternal() && filled($booking->guest?->email),
];
}
/**
* An agreed change (or a change of an internal case): takes effect at once.
*
* @param array<string, mixed> $changes
* @param array{requested_by: string, reason: string, basis: ChangeBasis, agreed_at?: ?string, effective_on?: ?string, send_confirmation?: bool} $meta
*
* @throws ReservationException
*/
public function apply(Booking $booking, array $changes, array $meta, ?string $by = null): BookingChange
{
$this->guard($booking);
if ($meta['basis'] === ChangeBasis::GuestLink) {
throw new ReservationException('Eine Zustimmung über den Link entsteht nur, wenn der Gast selbst annimmt.');
}
$change = DB::transaction(function () use ($booking, $changes, $meta, $by): BookingChange {
$booking->lockForTransition();
$preview = $this->preview($booking, $changes);
if ($preview['errors'] !== []) {
throw new ReservationException(implode(' ', $preview['errors']));
}
$change = $booking->changes()->create([
'status' => ChangeStatus::Applied, 'requested_by' => $meta['requested_by'], 'basis' => $meta['basis'],
'reason' => trim((string) $meta['reason']), 'effective_on' => $meta['effective_on'] ?? today()->toDateString(),
'agreed_at' => $meta['basis'] === ChangeBasis::NotNeeded ? null : ($meta['agreed_at'] ?? now()),
'agreed_by' => $meta['basis'] === ChangeBasis::NotNeeded ? null : ($booking->guest?->full_name ?? 'Gast'),
'before' => $preview['before'], 'after' => $preview['after'], 'consequences' => self::consequences($preview),
'applied_at' => now(), 'recorded_by' => $by,
]);
$change->tenant_id = $booking->tenant_id;
$change->save();
$this->write($booking, $preview, $meta['reason'], $by, $change);
return $change;
});
if ($meta['send_confirmation'] ?? false) {
$this->confirm($booking->fresh(), $change);
}
return $change->fresh();
}
/**
* A change the guest still has to agree to: nothing changes; the guest gets a link to accept or decline.
*
* @param array<string, mixed> $changes
* @param array{requested_by: string, reason: string, effective_on?: ?string, valid_days?: int} $meta
*
* @throws ReservationException
*/
public function propose(Booking $booking, array $changes, array $meta, ?string $by = null): BookingChange
{
$this->guard($booking);
if ($booking->isInternal() || $booking->caseType()->isExternallyBinding()) {
throw new ReservationException('Ein Vorschlag mit Zustimmungslink ist nur für eigene Buchungen möglich – Portalbuchungen werden im Portal geändert.');
}
if (blank($booking->guest?->email)) {
throw new ReservationException('Für einen Vorschlag wird die E-Mail-Adresse des Gastes benötigt.');
}
if ($booking->changes()->where('status', ChangeStatus::Proposed)->exists()) {
throw new ReservationException('Es liegt schon ein Änderungsvorschlag beim Gast. Bitte zuerst zurückziehen.');
}
$preview = $this->preview($booking, $changes);
if ($preview['errors'] !== []) {
throw new ReservationException(implode(' ', $preview['errors']));
}
$change = $booking->changes()->create([
'status' => ChangeStatus::Proposed, 'requested_by' => $meta['requested_by'], 'reason' => trim((string) $meta['reason']),
'effective_on' => $meta['effective_on'] ?? null, 'before' => $preview['before'], 'after' => $preview['after'],
'consequences' => self::consequences($preview), 'expires_at' => now()->addDays((int) ($meta['valid_days'] ?? 7)), 'recorded_by' => $by,
]);
$change->tenant_id = $booking->tenant_id;
$change->save();
CaseLog::record($booking, 'change', 'Änderung dem Gast vorgeschlagen: '.implode(' · ', $preview['summary']), $meta['reason'], data: ['booking_change_id' => $change->id]);
try {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new ChangeProposed($booking, $change, $this->link($change)));
} catch (Throwable $exception) {
Log::warning('Änderungsvorschlag nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
throw new ReservationException('Der Vorschlag ist gespeichert, aber die E-Mail konnte nicht versendet werden.');
}
return $change;
}
/**
* The guest accepts a proposed change through the signed link: the dates are checked again, then it takes effect.
*
* @throws ReservationException
*/
public function accept(BookingChange $change, ?string $ip = null): BookingChange
{
return DB::transaction(function () use ($change, $ip): BookingChange {
$booking = $change->booking;
$booking->lockForTransition();
$change = BookingChange::query()->whereKey($change->id)->lockForUpdate()->firstOrFail();
if ($change->status !== ChangeStatus::Proposed) {
throw new ReservationException('Dieser Vorschlag ist nicht mehr offen.');
}
if ($change->expires_at !== null && $change->expires_at->isPast()) {
$change->update(['status' => ChangeStatus::Expired]);
throw new ReservationException('Dieser Vorschlag ist abgelaufen. Bitte melden Sie sich bei uns.');
}
$after = (array) $change->after;
$preview = $this->preview($booking, [...$after, 'agreed_total' => $after['total'] ?? null, 'portal_total' => null]);
if ($preview['errors'] !== []) {
throw new ReservationException('Die Änderung ist leider nicht mehr möglich: '.implode(' ', $preview['errors']));
}
$change->update(['status' => ChangeStatus::Applied, 'basis' => ChangeBasis::GuestLink, 'agreed_at' => now(), 'agreed_by' => $booking->guest?->full_name,
'decided_at' => now(), 'decision_ip_hash' => $ip ? hash('sha256', $ip) : null, 'applied_at' => now()]);
CaseLog::context(fn () => $this->write($booking, $preview, (string) $change->reason, CaseLog::GUEST, $change), actor: CaseLog::GUEST);
return $change->fresh();
});
}
public function decline(BookingChange $change, ?string $ip = null): void
{
if ($change->status !== ChangeStatus::Proposed) {
return;
}
$change->update(['status' => ChangeStatus::Declined, 'decided_at' => now(), 'decision_ip_hash' => $ip ? hash('sha256', $ip) : null]);
CaseLog::record($change->booking, 'change', 'Änderungsvorschlag vom Gast abgelehnt', actor: CaseLog::GUEST, data: ['booking_change_id' => $change->id]);
}
public function withdraw(BookingChange $change, ?string $by = null): void
{
if ($change->status === ChangeStatus::Proposed) {
$change->update(['status' => ChangeStatus::Withdrawn, 'decided_at' => now()]);
CaseLog::record($change->booking, 'change', 'Änderungsvorschlag zurückgezogen', actor: $by);
}
}
/**
* The guest's signed link to a proposed change (valid while the proposal is).
*/
public function link(BookingChange $change): string
{
$until = $change->expires_at ?? now()->addDays(7);
return $change->booking->website()?->temporarySignedRoute('changes.show', $until, ['change' => $change])
?? URL::temporarySignedRoute('changes.show', $until, ['change' => $change]);
}
/**
* Sends the updated confirmation of an agreed change (information, not consent).
*/
public function confirm(Booking $booking, BookingChange $change): bool
{
if ($booking->isInternal() || blank($booking->guest?->email)) {
return false;
}
try {
Mail::to($booking->guest->email, $booking->guest->full_name)->send(new BookingChanged($booking, $change));
$change->update(['confirmation_sent_at' => now()]);
return true;
} catch (Throwable $exception) {
Log::warning('Änderungsbestätigung nicht zugestellt', ['booking' => $booking->id, 'exception' => $exception::class]);
return false;
}
}
/**
* @throws ReservationException
*/
private function guard(Booking $booking): void
{
if (! in_array($booking->status, BookingStatus::occupying(), true)) {
throw new ReservationException('Ändern lässt sich nur eine bestehende Buchung oder Belegung. Ein Angebot wird über „Angebot ändern & neu senden“ geändert.');
}
}
/**
* Writes the new state on the case (inside the transaction of the caller).
*
* @param array<string, mixed> $preview
*/
private function write(Booking $booking, array $preview, string $reason, ?string $by, BookingChange $change): void
{
$after = $preview['after'];
$booking->update([
'arrival' => $after['arrival'], 'departure' => $after['departure'], 'guests' => $after['guests'], 'extras' => $after['extras'],
'quote' => $after['quote'], 'total' => $after['total'], 'deposit' => $after['deposit'], 'balance_due_on' => $after['balance_due_on'],
'tourist_tax_persons' => $after['tourist_tax_persons'],
]);
CaseLog::record($booking, 'change', 'Geändert: '.implode(' · ', $preview['summary']), $reason, data: ['booking_change_id' => $change->id], actor: $by);
$this->payments->updateStatus($booking->fresh());
if ($preview['refund'] > 0) {
BookingTask::query()->updateOrCreate(['booking_id' => $booking->id, 'kind' => BookingTaskKind::RefundCheck], [
'tenant_id' => $booking->tenant_id, 'status' => BookingTaskStatus::Open, 'due_on' => today(),
'note' => 'Nach der Änderung zu viel bezahlt: '.Money::format($preview['refund']).' an den Gast erstatten (als „Erstattung“ erfassen).',
'completed_by' => null, 'completed_at' => null,
]);
}
}
/**
* The new price and where it comes from.
*
* @param array<string, mixed> $changes
* @param array<int, int> $extras
* @return array{0: ?array{quote: array<string, mixed>, total: int, deposit: ?int, balance_due_on: ?string}, 1: string, 2: ?string}
*/
private function price(Booking $booking, array $changes, CarbonImmutable $arrival, CarbonImmutable $departure, ?int $guests, array $extras): array
{
if ($booking->isInternal()) {
try {
$rent = array_key_exists('rent', $changes) && $changes['rent'] !== null ? (int) $changes['rent'] : PrivateStayPrice::rentOf($booking->quote);
$taxPersons = array_key_exists('tourist_tax_persons', $changes) ? ($changes['tourist_tax_persons'] === null ? null : (int) $changes['tourist_tax_persons']) : $booking->tourist_tax_persons;
$quote = $this->privateStay->quote($booking->property, $arrival, $departure, $guests, $extras, $rent, $taxPersons);
return [['quote' => $quote->toArray(), 'total' => $quote->total(), 'deposit' => null, 'balance_due_on' => null], 'vereinbart (Miete, Leistungen, Kurabgabe)', null];
} catch (QuoteException $exception) {
return [null, '–', $exception->getMessage()];
}
}
if ($booking->caseType()->isExternallyBinding() || ($booking->quote['source'] ?? null) === 'portal') {
$total = filled($changes['portal_total'] ?? null) ? (int) $changes['portal_total'] : $booking->total;
if ($total === null) {
return [null, 'laut Portal – noch nicht bekannt', null];
}
$columns = $this->portalPrice->columns($booking->property, $arrival, $departure, $guests, $total, $booking->processChannel()?->name);
return [['quote' => $columns['quote'], 'total' => (int) $columns['total'], 'deposit' => $columns['deposit'], 'balance_due_on' => $columns['balance_due_on']],
filled($changes['portal_total'] ?? null) ? 'neuer Gesamtpreis laut Portal' : 'Gesamtpreis laut Portal unverändert – bitte neuen Betrag eintragen, falls das Portal ihn geändert hat', null];
}
$agreed = filled($changes['agreed_total'] ?? null) ? (int) $changes['agreed_total'] : null;
try {
$quote = $this->calculator->calculate($booking->property, new StayRequest($arrival, $departure, max(1, (int) $guests), $extras, $booking->promo_code));
foreach ((array) ($booking->quote['lines'] ?? []) as $line) {
if (($line['type'] ?? null) === QuoteLineType::Adjustment->value) {
$quote = $quote->withLine(new QuoteLine(QuoteLineType::Adjustment, (string) $line['label'], 1, (int) $line['amount'], (int) $line['amount']));
}
}
$source = 'aus Ihren Preisen neu berechnet';
} catch (QuoteException $exception) {
if ($agreed === null) {
return [null, '–', 'Preis: '.$exception->getMessage().' Bitte einen vereinbarten Preis eintragen.'];
}
$quote = new PriceQuote($arrival, $departure, (int) $guests, [new QuoteLine(QuoteLineType::Accommodation, 'Vereinbarter Preis', 1, $agreed, $agreed)], $booking->property->deposit_percent, $arrival->subDays($booking->property->balance_due_days_before_arrival));
$source = 'vereinbarter Preis';
}
if ($agreed !== null && $agreed !== $quote->total()) {
$label = trim((string) ($changes['agreed_total_label'] ?? '')) ?: 'Vereinbarte Preisanpassung';
$quote = $quote->withLine(new QuoteLine(QuoteLineType::Adjustment, $label, 1, $agreed - $quote->total(), $agreed - $quote->total()));
$source = 'vereinbarter Preis';
}
return [['quote' => $quote->toArray(), 'total' => $quote->total(), 'deposit' => $quote->deposit(), 'balance_due_on' => $quote->balanceDueOn->toDateString()], $source, null];
}
/**
* What happens in the calendar and on the portals that are blocked by hand.
*
* @return array{0: list<string>, 1: list<string>}
*/
private function calendarConsequences(Booking $booking, CarbonImmutable $arrival, CarbonImmutable $departure): array
{
$oldStart = $booking->arrival;
$oldEnd = $booking->departure;
if ($arrival->equalTo($oldStart) && $departure->equalTo($oldEnd)) {
return [['Kalender unverändert.'], []];
}
$added = array_values(array_filter([
$arrival->lessThan($oldStart) ? [$arrival, $oldStart->min($departure)] : null,
$departure->greaterThan($oldEnd) ? [$oldEnd->max($arrival), $departure] : null,
]));
$freed = array_values(array_filter([
$oldStart->lessThan($arrival) ? [$oldStart, $arrival->min($oldEnd)] : null,
$oldEnd->greaterThan($departure) ? [$departure->max($oldStart), $oldEnd] : null,
]));
$range = fn (array $pair): string => $pair[0]->format('d.m.').'–'.$pair[1]->format('d.m.Y');
$calendar = [
...array_map(fn (array $pair): string => 'Neu belegt: '.$range($pair), $added),
...array_map(fn (array $pair): string => 'Wieder frei: '.$range($pair), $freed),
'Die Kalender für die Portale zeigen den neuen Zeitraum beim nächsten Abruf.',
];
$origin = $booking->origin_channel_id ?? $booking->import_channel_id;
$portals = $booking->property->channels()->active()->where('requires_manual_blocking', true)->get()
->filter(fn (Channel $channel): bool => $channel->exportsOccupations() && $channel->id !== $origin)
->map(fn (Channel $channel): string => 'Aufgabe für '.$channel->name.': '.implode(', ', [...array_map(fn (array $pair): string => 'sperren '.$range($pair), $added), ...array_map(fn (array $pair): string => 'freigeben '.$range($pair), $freed)]))
->values()->all();
if ($booking->caseType()->isExternallyBinding()) {
$portals[] = 'Die Änderung selbst muss im Portal „'.($booking->processChannel()?->name ?? 'Portal').'“ vorliegen – hier wird sie nur nachgetragen.';
}
return [$calendar, $portals];
}
/**
* @return array<string, mixed>
*/
private static function snapshot(Booking $booking): array
{
return [
'arrival' => $booking->arrival->toDateString(), 'departure' => $booking->departure->toDateString(), 'guests' => $booking->guests,
'extras' => (array) ($booking->extras ?? []), 'quote' => $booking->quote, 'total' => $booking->total, 'deposit' => $booking->deposit,
'balance_due_on' => $booking->balance_due_on?->toDateString(), 'tourist_tax_persons' => $booking->tourist_tax_persons,
];
}
/**
* @param array<string, mixed> $before
* @param array<string, mixed> $after
* @return list<string>
*/
private static function summary(array $before, array $after): array
{
$date = fn (?string $value): string => $value ? CarbonImmutable::parse($value)->format('d.m.Y') : '–';
$lines = [];
if ($before['arrival'] !== $after['arrival'] || $before['departure'] !== $after['departure']) {
$lines[] = 'Zeitraum '.$date($before['arrival']).'–'.$date($before['departure']).' → '.$date($after['arrival']).'–'.$date($after['departure']);
}
if ($before['guests'] !== $after['guests']) {
$lines[] = 'Personen '.($before['guests'] ?? '?').' → '.($after['guests'] ?? '?');
}
if ((array) $before['extras'] != (array) $after['extras']) {
$lines[] = 'Zusatzleistungen geändert';
}
if ($before['total'] !== $after['total']) {
$lines[] = 'Preis '.($before['total'] === null ? '–' : Money::format($before['total'])).' → '.($after['total'] === null ? '–' : Money::format($after['total']));
}
return $lines === [] ? ['keine inhaltliche Änderung'] : $lines;
}
/**
* @param array<string, mixed> $preview
* @return array<string, mixed>
*/
private static function consequences(array $preview): array
{
return ['summary' => $preview['summary'], 'calendar' => $preview['calendar'], 'portals' => $preview['portals'], 'price' => $preview['price'], 'payment' => $preview['payment'], 'refund' => $preview['refund']];
}
}
+6 -1
View File
@@ -12,6 +12,7 @@
use App\Filament\Resources\Bookings\BookingResource;
use App\Mail\BookingConfirmed;
use App\Mail\BookingDocumentation;
use App\Mail\StayConfirmed;
use App\Models\Booking;
use App\Process\CaseLog;
use App\Support\Inbox;
@@ -108,7 +109,11 @@ public function deliver(Booking $booking, bool $notifyGuest = true, ?DocumentKin
return true;
}
Mail::to($booking->guest->email, $booking->guest->full_name)->send($kind === DocumentKind::ExternalRecord ? new BookingDocumentation($booking) : new BookingConfirmed($booking));
Mail::to($booking->guest->email, $booking->guest->full_name)->send(match ($kind) {
DocumentKind::ExternalRecord => new BookingDocumentation($booking),
DocumentKind::StayConfirmation => new StayConfirmed($booking),
default => new BookingConfirmed($booking),
});
$booking->forceFill(['confirmation_sent_at' => now(), 'confirmation_failed_at' => null])->save();
return true;
+97
View File
@@ -0,0 +1,97 @@
<?php
namespace App\Actions;
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
use App\Enums\IntakeKind;
use App\Enums\InternalKind;
use App\Exceptions\ReservationException;
use App\Models\Booking;
use App\Models\Guest;
use App\Models\Property;
use App\Pricing\PrivateStayPrice;
use App\Pricing\QuoteException;
use App\Process\CaseLog;
use Carbon\CarbonImmutable;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
/**
* Own use, a private stay or a block as a case (A6, package 6): the dates are occupied at once and the portals are
* blocked like for any booking. A block has nothing but dates and an occasion; own use and private stays may have
* guests, services, an agreed rent (0 by default), the tourist tax and payments – but never a rental contract, payment
* reminders, reviews or marketing (the A6 profile switches them off).
*/
class CreateInternalCase
{
public function __construct(private AvailabilityChecker $availability, private PrivateStayPrice $price) {}
/**
* @param array{occasion?: ?string, guest?: ?array<string, ?string>, guests?: ?int, extras?: ?array<int, int>, rent?: ?int, tourist_tax_persons?: ?int, tourist_tax_note?: ?string, notes?: ?string} $data
*
* @throws ReservationException
* @throws QuoteException
*/
public function handle(Property $property, InternalKind $kind, CarbonImmutable $arrival, CarbonImmutable $departure, array $data = []): Booking
{
if ($departure->lessThanOrEqualTo($arrival)) {
throw new ReservationException('Das Ende muss nach dem Beginn liegen.');
}
return DB::transaction(function () use ($property, $kind, $arrival, $departure, $data): Booking {
Property::query()->whereKey($property->id)->lockForUpdate()->firstOrFail();
if (! $this->availability->isAvailable($property, $arrival, $departure)) {
throw ReservationException::notAvailable();
}
$guests = $kind === InternalKind::Block ? null : (filled($data['guests'] ?? null) ? (int) $data['guests'] : null);
$extras = $kind === InternalKind::Block ? [] : array_filter(array_map('intval', (array) ($data['extras'] ?? [])));
$taxPersons = $kind === InternalKind::Block ? null : (filled($data['tourist_tax_persons'] ?? null) ? (int) $data['tourist_tax_persons'] : null);
$quote = $kind === InternalKind::Block ? null : $this->price->quote($property, $arrival, $departure, $guests, $extras, (int) ($data['rent'] ?? 0), $taxPersons);
$guest = $kind->hasGuests() ? $this->guest((array) ($data['guest'] ?? [])) : null;
$booking = $property->bookings()->create([
'guest_id' => $guest?->id,
'status' => BookingStatus::Confirmed,
'source' => 'internal',
'intake' => IntakeKind::Internal,
'internal_kind' => $kind,
'occasion' => filled($data['occasion'] ?? null) ? trim((string) $data['occasion']) : null,
'arrival' => $arrival->toDateString(),
'departure' => $departure->toDateString(),
'guests' => $guests,
'extras' => $extras,
'quote' => $quote?->toArray(),
'total' => $quote?->total(),
'tourist_tax_persons' => $taxPersons,
'tourist_tax_note' => filled($data['tourist_tax_note'] ?? null) ? trim((string) $data['tourist_tax_note']) : null,
'confirmed_at' => now(),
'internal_notes' => filled($data['notes'] ?? null) ? trim((string) $data['notes']) : null,
]);
CaseLog::record($booking, 'intake', $kind->getLabel().' eingetragen'.($booking->occasion ? ': '.$booking->occasion : ''));
return $booking;
});
}
/**
* The guest of a private stay – only with a real name; a known e-mail address finds the existing guest.
*
* @param array<string, ?string> $data
*/
private function guest(array $data): ?Guest
{
$data = array_map(fn ($value) => filled($value) ? trim((string) $value) : null, Arr::only($data, ['first_name', 'last_name', 'email', 'phone', 'street', 'postal_code', 'city']));
if (blank($data['first_name'] ?? null) || blank($data['last_name'] ?? null)) {
return null;
}
$email = filled($data['email'] ?? null) ? mb_strtolower($data['email']) : null;
if ($email !== null && ($known = Guest::query()->where('email', $email)->whereNull('anonymized_at')->first()) !== null) {
return $known;
}
return Guest::query()->create([...array_filter($data, fn ($value) => $value !== null), 'email' => $email ?? '']);
}
}
+42
View File
@@ -0,0 +1,42 @@
<?php
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\InternalKind;
use App\Exceptions\ReservationException;
use App\Models\Booking;
use App\Process\CaseLog;
use Illuminate\Support\Facades\DB;
/**
* Lifts a block or calls off an own use / private stay (A6). It is no cancellation: no costs, no refund rule, no mails –
* the dates are free again and the portals are released like for any booking that ends.
*/
class EndInternalCase
{
/**
* @throws ReservationException
*/
public function handle(Booking $booking, string $reason, ?string $by = null): void
{
if (! $booking->isInternal()) {
throw new ReservationException('Nur eigene Nutzung, private Aufenthalte und Sperren werden so beendet.');
}
DB::transaction(function () use ($booking, $reason, $by): void {
$booking->lockForTransition();
if (! in_array($booking->status, BookingStatus::occupying(), true)) {
throw ReservationException::invalidTransition($booking->status->getLabel(), 'aufgehoben');
}
CaseLog::context(fn () => $booking->update(['status' => BookingStatus::Cancelled, 'cancelled_at' => now()]), actor: $by, reason: $reason);
CaseLog::record($booking, 'status', self::label($booking), $reason, actor: $by);
});
}
public static function label(Booking $booking): string
{
return $booking->internal_kind === InternalKind::Block ? 'Sperre aufgehoben' : 'Aufenthalt abgesagt';
}
}
+21
View File
@@ -3,6 +3,7 @@
namespace App\Actions;
use App\Channels\ConflictDetector;
use App\Channels\Intake\PortalIntake;
use App\Channels\Mail\ParsedPortalMail;
use App\Channels\Mail\PortalMail;
use App\Channels\Mail\PortalMailParser;
@@ -12,6 +13,7 @@
use App\Mail\PortalMailNotification;
use App\Models\BlockedPeriod;
use App\Models\Channel;
use App\Models\IntakeObservation;
use App\Models\PortalEmail;
use App\Support\Settings;
use App\Tenancy\TenantFeatures;
@@ -75,6 +77,9 @@ public function handle(PortalMail $mail): ?PortalEmail
]);
});
// One intake for all channels (package 4): bookings, requests and cancellations reach their case.
rescue(fn () => $this->intake($channel, $parsed, $record));
if (in_array($record->status, [PortalEmailStatus::Blocked, PortalEmailStatus::Released, PortalEmailStatus::NeedsReview], true)) {
rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new PortalMailNotification($record)));
}
@@ -86,6 +91,17 @@ public function handle(PortalMail $mail): ?PortalEmail
return $record;
}
private function intake(Channel $channel, ParsedPortalMail $parsed, PortalEmail $record): void
{
$intake = app(PortalIntake::class);
match ($parsed->type) {
PortalEmailType::Booking => $record->blocked_period_id !== null ? $intake->process(BlockedPeriod::query()->findOrFail($record->blocked_period_id), IntakeObservation::SOURCE_MAIL) : null,
PortalEmailType::Cancellation => $intake->cancellationMail($channel, $parsed, $record),
PortalEmailType::Inquiry => $intake->inquiryMail($channel, $parsed, $record),
PortalEmailType::Unknown => null,
};
}
/**
* Channels list the sender addresses or domains of their notification e-mails in settings.email_senders.
*/
@@ -177,6 +193,11 @@ private function release(Channel $channel, ParsedPortalMail $parsed): array
default => null,
};
// A block that belongs to a case is never released by a mail: the case leads, the landlord decides (E-019).
if ($block && $block->linked_booking_id !== null) {
return [PortalEmailStatus::NeedsReview, $block, 'Stornierung zu einem gebuchten Vorgang gemeldet – nichts automatisch freigegeben; Aufgabe am Vorgang prüfen.'];
}
if ($block) {
$block->delete();
+10 -4
View File
@@ -3,6 +3,7 @@
namespace App\Actions;
use App\Enums\BookingStatus;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Models\Booking;
use App\Models\Payment;
@@ -10,20 +11,25 @@
use Illuminate\Support\Facades\DB;
/**
* Records a received payment (or a refund with a negative amount) and moves the booking along:
* Bestätigt → Anzahlung erhalten → Bezahlt.
* Records a payment of a case with its kind (package 8): the guest paid us, the portal reports the guest paid it, the
* portal paid out to us, or we refunded the guest. Only the guest's payments move the booking along
* (Bestätigt → Anzahlung erhalten → Bezahlt); a refund is stored as a negative amount.
*/
class RecordPayment
{
public function handle(Booking $booking, int $amount, CarbonInterface $paidOn, PaymentMethod $method = PaymentMethod::Transfer, ?string $note = null, ?string $recordedBy = null): Payment
public function handle(Booking $booking, int $amount, CarbonInterface $paidOn, PaymentMethod $method = PaymentMethod::Transfer, ?string $note = null, ?string $recordedBy = null, PaymentKind $kind = PaymentKind::Guest, ?string $source = null): Payment
{
return DB::transaction(function () use ($booking, $amount, $paidOn, $method, $note, $recordedBy): Payment {
$amount = $kind === PaymentKind::Refund ? -abs($amount) : $amount;
return DB::transaction(function () use ($booking, $amount, $paidOn, $method, $note, $recordedBy, $kind, $source): Payment {
$payment = $booking->payments()->create([
'amount' => $amount,
'paid_on' => $paidOn->toDateString(),
'method' => $method,
'note' => $note,
'recorded_by' => $recordedBy,
'kind' => $kind,
'source' => $source,
]);
$booking->unsetRelation('payments');
+67
View File
@@ -0,0 +1,67 @@
<?php
namespace App\Actions;
use App\Enums\AmountKind;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Models\Booking;
use App\Pricing\PortalPrice;
use App\Process\CaseAutomation;
use App\Process\CaseLog;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
/**
* Takes over what a portal shows about a booking (package 8): the guest's total as the agreed price ("Gesamtpreis laut
* Portal"), and – as far as the portal shows them – price positions, collective amounts, commission, announced payouts,
* instalments and what the guest has paid to the portal. Every value is stored with its source and date as stated; the
* total is never recalculated from the positions, and a statement entered twice is stored once.
*/
class RecordPortalAmounts
{
public function __construct(private PortalPrice $price, private RecordPayment $payments) {}
/**
* @param list<array{kind: AmountKind|string, label?: ?string, amount: int, due_on?: ?string, note?: ?string}> $amounts
* @param list<array{amount: int, paid_on: string}> $paidViaPortal instalments the portal shows as paid by the guest
*/
public function handle(Booking $booking, ?int $guestTotal, array $amounts, array $paidViaPortal, string $source, ?CarbonImmutable $statedOn = null, ?string $by = null): void
{
$statedOn ??= CarbonImmutable::today();
DB::transaction(function () use ($booking, $guestTotal, $amounts, $paidViaPortal, $source, $statedOn, $by): void {
if ($guestTotal !== null && $guestTotal !== $booking->total) {
$before = $booking->total;
$booking->update($this->price->columns($booking->property, $booking->arrival, $booking->departure, $booking->guests, $guestTotal, $source));
CaseLog::record($booking, 'price', 'Gesamtpreis laut '.$source.': '.Money::format($guestTotal).($before !== null ? ' (vorher '.Money::format($before).')' : ''));
}
foreach ($amounts as $row) {
$kind = $row['kind'] instanceof AmountKind ? $row['kind'] : AmountKind::from((string) $row['kind']);
$label = filled($row['label'] ?? null) ? trim((string) $row['label']) : null;
$exists = $booking->amounts()->where('kind', $kind)->where('amount', (int) $row['amount'])->where('source', $source)
->where(fn ($query) => $label === null ? $query->whereNull('label') : $query->where('label', $label))->exists();
if ($exists) {
continue;
}
$booking->amounts()->create([
'kind' => $kind, 'label' => $label, 'amount' => (int) $row['amount'], 'source' => $source,
'stated_on' => $statedOn->toDateString(), 'due_on' => filled($row['due_on'] ?? null) ? $row['due_on'] : null,
'note' => filled($row['note'] ?? null) ? trim((string) $row['note']) : null, 'recorded_by' => $by,
]);
}
foreach ($paidViaPortal as $row) {
$paidOn = CarbonImmutable::parse($row['paid_on']);
$known = $booking->payments()->where('kind', PaymentKind::GuestViaPortal)->where('amount', (int) $row['amount'])->whereDate('paid_on', $paidOn)->exists();
if (! $known) {
$this->payments->handle($booking, (int) $row['amount'], $paidOn, PaymentMethod::Other, 'laut '.$source, $by, PaymentKind::GuestViaPortal, $source);
}
}
});
app(CaseAutomation::class)->advance($booking->fresh());
}
}
+1 -1
View File
@@ -81,7 +81,7 @@ public static function kindFor(Booking $booking): DocumentKind
{
$kind = DocumentKind::forCase($booking);
return in_array($kind, [DocumentKind::Confirmation, DocumentKind::ExternalRecord], true) ? $kind : DocumentKind::Confirmation;
return in_array($kind, [DocumentKind::Confirmation, DocumentKind::ExternalRecord, DocumentKind::StayConfirmation], true) ? $kind : DocumentKind::Confirmation;
}
private function send(Booking $booking, DocumentComposition $composition, bool $acknowledged, bool $automatic): bool
+3
View File
@@ -5,6 +5,7 @@
use App\Channels\ChannelSyncException;
use App\Channels\ConflictDetector;
use App\Channels\ExternalPeriod;
use App\Channels\Intake\PortalIntake;
use App\Enums\ChannelEchoBehavior;
use App\Models\BlockedPeriod;
use App\Models\Booking;
@@ -135,6 +136,8 @@ public function handle(Channel $channel): ChannelSyncLog
'alerted_at' => null, 'last_import_events' => count($periods), 'sync_warnings' => $warnings])->save();
});
app(ReportChannelConflicts::class)->handle($channel, $conflicts);
// One intake for all channels (package 4); a failure there never fails the sync itself.
rescue(fn () => app(PortalIntake::class)->afterSync($channel->fresh()));
return $channel->syncLogs()->create(['successful' => true, 'events' => count($periods), ...$counts,
'conflicts' => count($conflicts), 'warnings' => $warnings,
+3 -1
View File
@@ -5,6 +5,7 @@
use App\Enums\BookingStatus;
use App\Enums\IntakeKind;
use App\Enums\OccupationKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
use App\Models\BlockedPeriod;
use App\Models\Booking;
@@ -31,7 +32,7 @@ class TakeOverExternalBooking
public function __construct(private ConfirmBooking $confirm, private PortalPrice $price) {}
/**
* @param array{guest?: ?array<string, ?string>, guests?: ?int, portal_reference?: ?string, portal_total?: ?int, notes?: ?string, guest_confirmed?: bool} $facts
* @param array{guest?: ?array<string, ?string>, guests?: ?int, portal_reference?: ?string, portal_total?: ?int, notes?: ?string, guest_confirmed?: bool, processing_mode?: ?ProcessingMode} $facts
*
* @throws ReservationException
*/
@@ -73,6 +74,7 @@ public function handle(Property $property, Channel $channel, CarbonImmutable $ar
'hold_expires_at' => null,
'guest_confirmed_at' => ($facts['guest_confirmed'] ?? false) ? now() : null,
'internal_notes' => filled($facts['notes'] ?? null) ? trim((string) $facts['notes']) : null,
'processing_mode' => $facts['processing_mode'] ?? null,
...$this->price->columns($property, $arrival, $departure, $guests, $portalTotal, $channel->name),
]);
+63
View File
@@ -0,0 +1,63 @@
<?php
namespace App\Actions;
use App\Availability\AvailabilityChecker;
use App\Enums\BookingStatus;
use App\Enums\IntakeKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
use App\Models\Booking;
use App\Models\Channel;
use App\Process\CaseAutomation;
use App\Process\ProcessSettings;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\DB;
/**
* A non-binding request through a portal (case type A2) as it arrives: dates and the portal's reference, nothing
* invented. Guest, number of guests and price stay unknown until the landlord enters them; the case then asks for
* exactly that and continues like a request of the own website. Whether the dates are reserved follows the channel's
* settings for requests.
*/
class TakeOverPortalInquiry
{
public function __construct(private AvailabilityChecker $availability, private ProcessSettings $settings) {}
/**
* @throws ReservationException
*/
public function handle(Channel $channel, CarbonImmutable $arrival, CarbonImmutable $departure, ?string $reference = null, ?string $notes = null, ?ProcessingMode $processingMode = null): Booking
{
$property = $channel->property;
if ($departure->lessThanOrEqualTo($arrival)) {
throw new ReservationException('Die Abreise muss nach der Anreise liegen.');
}
$booking = DB::transaction(function () use ($property, $channel, $arrival, $departure, $reference, $notes, $processingMode): Booking {
$property->newQuery()->whereKey($property->id)->lockForUpdate()->firstOrFail();
if (! $this->availability->isAvailable($property, $arrival, $departure)) {
throw ReservationException::notAvailable();
}
$profile = $this->settings->resolve($property, $channel, IntakeKind::Inquiry);
return $property->bookings()->create([
'status' => BookingStatus::Reserved,
'source' => 'portal',
'intake' => IntakeKind::Inquiry,
'origin_channel_id' => $channel->id,
'portal_reference' => $reference,
'arrival' => $arrival->toDateString(),
'departure' => $departure->toDateString(),
'hold_expires_at' => $profile->preReservation() ? now()->addHours($profile->holdHours()) : null,
'processing_mode' => $processingMode,
'internal_notes' => $notes,
]);
});
app(CaseAutomation::class)->advance($booking);
return $booking->refresh();
}
}
+10
View File
@@ -41,6 +41,16 @@ public function properties(Channel $channel, Booking|BlockedPeriod $occupation):
/** @return array<string, string|null> */
public function context(Booking|BlockedPeriod $occupation): array
{
// Own use, private stays and blocks (A6) are exported exactly like the manual blocks they replace: no reference;
// a guest's name only where the channel exports names at all.
if ($occupation instanceof Booking && $occupation->isInternal()) {
$guest = $occupation->guest?->anonymized_at === null ? $occupation->guest : null;
return ['occupation_label' => 'Belegt', 'property_name' => $occupation->property->name, 'arrival' => $occupation->arrival->format('d.m.Y'),
'departure' => $occupation->departure->format('d.m.Y'), 'nights' => (string) (int) $occupation->arrival->diffInDays($occupation->departure), 'channel_name' => null,
...($guest !== null ? ['guest_first_name' => $guest->first_name, 'guest_full_name' => filled($guest->last_name) ? $guest->full_name : null] : [])];
}
$booking = $occupation instanceof Booking;
$start = $booking ? $occupation->arrival : $occupation->starts_on;
$end = $booking ? $occupation->departure : $occupation->ends_on;
+2 -1
View File
@@ -33,7 +33,8 @@ public function build(Channel $channel): string
}
foreach ($bookings->with(['guest', 'property'])->orderBy('id')->get() as $booking) {
/** @var Booking $booking */
$events[] = $this->event("booking-{$booking->id}{$suffix}", $booking->arrival, $booking->departure, $booking->updated_at, (new ICalExportFields)->properties($channel, $booking));
// A block taken over as a case keeps the identity the portals already know.
$events[] = $this->event(($booking->export_uid ?? "booking-{$booking->id}").$suffix, $booking->arrival, $booking->departure, $booking->updated_at, (new ICalExportFields)->properties($channel, $booking));
}
$blocks = $property->blockedPeriods()
+39
View File
@@ -0,0 +1,39 @@
<?php
namespace App\Channels\Intake;
use App\Enums\CaseType;
use App\Enums\IntakeOutcome;
use App\Models\Booking;
/**
* What the intake recognised in one incoming portal event, with its reasons in plain words.
*/
final class IntakeDecision
{
/**
* @param list<string> $reasons why the intake decided so
* @param list<string> $missing what the new case will not know yet
*/
public function __construct(
public readonly IntakeOutcome $outcome,
public readonly array $reasons = [],
public readonly ?Booking $booking = null,
public readonly ?CaseType $caseType = null,
public readonly array $missing = [],
public readonly ?string $reference = null,
) {}
public function withBooking(Booking $booking): self
{
return new self($this->outcome, $this->reasons, $booking, $this->caseType ?? $booking->case_type, $this->missing, $this->reference);
}
/**
* @param list<string> $reasons
*/
public function as(IntakeOutcome $outcome, array $reasons): self
{
return new self($outcome, $reasons, $this->booking, $this->caseType, $this->missing, $this->reference);
}
}
+489
View File
@@ -0,0 +1,489 @@
<?php
namespace App\Channels\Intake;
use App\Actions\ReconcileChannelRepresentations;
use App\Actions\TakeOverExternalBooking;
use App\Actions\TakeOverPortalInquiry;
use App\Channels\Mail\ParsedPortalMail;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\CaseIntakeMode;
use App\Enums\ChannelBookingModel;
use App\Enums\IntakeKind;
use App\Enums\IntakeOutcome;
use App\Enums\OccupationKind;
use App\Enums\ProcessingMode;
use App\Exceptions\ReservationException;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\BookingTask;
use App\Models\Channel;
use App\Models\IntakeObservation;
use App\Models\PortalEmail;
use App\Pricing\QuoteException;
use App\Process\CaseLog;
use App\Process\ProcessSettings;
use Carbon\CarbonImmutable;
use Illuminate\Support\Collection;
use Throwable;
/**
* The one intake for bookings and requests from portals (UMSETZUNGSPLAN_v0.10 §5.5, package 4). Every incoming event –
* an entry of a portal calendar, a booking, request or cancellation e-mail – is judged the same way:
*
* - **Same case first** (no duplicates): an entry already linked to a case; the portal's booking reference; the same
* portal with exactly the same nights; the calendar mirror of an entry that belongs to a case. Different references
* or overlapping but different dates are never merged – they are clarified.
* - **New case only when certain**: a booking e-mail of the portal with dates and reference, or a calendar entry that
* the channel's rules recognise as a reservation booked at this portal (or that the landlord classified so). Blocks,
* mirrors of other portals, own use and unrecognised entries never become cases by themselves.
* - **Reports about known cases** (cancellation e-mail, entry gone from the calendar, other dates) become a task on the
* case and an entry in its history – the case itself is never cancelled, released or changed here (E-019).
*
* What happens then depends on the channel ({@see CaseIntakeMode}): nothing (off), only a record (observe), or the
* cases and tasks are created (create; continue additionally lets the new cases follow the automatic handling).
* Creating a case never sends anything the landlord did not release (package 3).
*/
class PortalIntake
{
public const LINK_NOTE = 'Automatisch dem Vorgang zugeordnet; der Vorgang führt diese Belegung.';
public function __construct(
private TakeOverExternalBooking $takeOver,
private TakeOverPortalInquiry $inquiry,
private ProcessSettings $settings,
) {}
/**
* Judges one portal calendar entry or e-mail block without changing anything.
*/
public function evaluate(BlockedPeriod $block): IntakeDecision
{
$block->loadMissing(['channel', 'property', 'canonicalBlock', 'linkedBooking']);
$channel = $block->channel;
$reference = self::reference($block);
if ($channel === null || ! in_array($block->source, ['channel', 'email'], true)) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Kein importierter Portaleintrag.'], reference: $reference);
}
if ($block->trashed()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Nicht mehr im Kalender des Portals.'], reference: $reference);
}
if ($block->linked_booking_id !== null && $block->linkedBooking !== null) {
return new IntakeDecision(IntakeOutcome::Link, ['Bereits dem Vorgang zugeordnet.'], $block->linkedBooking, reference: $reference);
}
if ($block->is_representation) {
$leaderCase = $block->canonicalBlock?->linkedBooking;
return $leaderCase !== null
? new IntakeDecision(IntakeOutcome::Link, ['Spiegelung einer Belegung, die zu diesem Vorgang gehört.'], $leaderCase, reference: $reference)
: new IntakeDecision(IntakeOutcome::Ignore, ['Spiegelung einer anderen Belegung, keine eigene Buchung.'], reference: $reference);
}
if ($reference !== null && ($case = $this->caseByReference($channel, $reference)) !== null) {
return new IntakeDecision(IntakeOutcome::Link, ['Gleiche Buchungsnummer '.$reference.' wie der Vorgang.'], $case, reference: $reference);
}
if ($block->ends_on->lessThanOrEqualTo(CarbonImmutable::today())) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Liegt in der Vergangenheit.'], reference: $reference);
}
if ($block->occupationKind() === OccupationKind::Block) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Als Sperrzeit eingeordnet (z. B. Spiegelung, eigene Nutzung oder Wartung).'], reference: $reference);
}
if ($block->is_private) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Als private Belegung eingeordnet.'], reference: $reference);
}
$origin = $block->origin_channel_id;
if ($origin !== null && $origin !== $channel->id) {
$case = $this->caseWithSameNights($block, $origin);
return $case !== null
? new IntakeDecision(IntakeOutcome::Link, ['Laut Kalender über ein anderes Portal gebucht; dort gibt es den Vorgang mit genau diesen Nächten.'], $case, reference: $reference)
: new IntakeDecision(IntakeOutcome::Clarify, ['Laut Kalender über ein anderes Portal gebucht – der Vorgang entsteht dort, nicht hier.'], reference: $reference);
}
$case = $this->caseWithSameNights($block, $channel->id);
if ($case !== null) {
return filled($case->portal_reference) && $reference !== null && $case->portal_reference !== $reference
? new IntakeDecision(IntakeOutcome::Clarify, ['Gleiche Nächte wie Vorgang '.$case->reference.', aber andere Buchungsnummer ('.$reference.' / '.$case->portal_reference.').'], reference: $reference)
: new IntakeDecision(IntakeOutcome::Link, ['Dasselbe Portal mit genau denselben Nächten wie Vorgang '.$case->reference.'.'], $case, reference: $reference);
}
$overlap = Booking::query()->occupying()->where('property_id', $block->property_id)->overlapping($block->starts_on, $block->ends_on)->first();
if ($overlap !== null) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Überschneidet sich mit Vorgang '.$overlap->reference.' ('.$overlap->arrival->format('d.m.').'–'.$overlap->departure->format('d.m.Y').'), ohne dieselbe Buchung zu sein.'], reference: $reference);
}
$sameChannelOverlap = $channel->blockedPeriods()->occupying()->whereKeyNot($block->id)->overlapping($block->starts_on, $block->ends_on)->exists();
if ($sameChannelOverlap) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Weitere Einträge desselben Portals überschneiden sich – keine Zusammenführung nach Terminen.'], reference: $reference);
}
$certainty = $this->certainty($block, $reference);
if ($certainty !== null) {
return new IntakeDecision(IntakeOutcome::Clarify, [$certainty], reference: $reference);
}
if ($channel->booking_model === ChannelBookingModel::Inquiry) {
return new IntakeDecision(IntakeOutcome::Clarify, ['Über dieses Portal kommen laut Einstellung nur Anfragen – eine feste Buchung bitte bestätigen.'], reference: $reference);
}
$profile = $this->settings->resolve($block->property, $channel, IntakeKind::Booking);
$fields = (array) ($block->ical_interpretation['fields'] ?? []);
return new IntakeDecision(
IntakeOutcome::Create,
[$block->source === 'email' ? 'Buchungsmail von '.$channel->name.' mit Zeitraum und Buchungsnummer.' : 'Kalendereintrag nach Regel „'.($block->ical_interpretation['rule'] ?? 'persönlich eingeordnet').'“ als Buchung bei '.$channel->name.' erkannt.'],
caseType: $profile->caseType,
missing: array_values(array_filter([
blank($fields['guest_full_name'] ?? null) ? 'Name des Gastes' : 'Name des Gastes (nur als Hinweis aus dem Kalender)',
'E-Mail-Adresse des Gastes',
'Personenzahl',
'Gesamtpreis laut Portal',
$reference === null ? 'Buchungsnummer' : null,
])),
reference: $reference,
);
}
/**
* Judges an entry and acts as the channel allows: records what was recognised and – only when the channel creates
* cases – creates the case, links the entry to its case or marks it for clarification.
*/
public function process(BlockedPeriod $block, string $source): IntakeDecision
{
$channel = $block->channel;
$mode = $channel?->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Automatische Übernahme ist für dieses Portal aus.']);
}
$decision = $this->evaluate($block);
$applied = false;
if ($mode->creates()) {
[$decision, $applied] = match ($decision->outcome) {
IntakeOutcome::Create => $this->create($block, $decision, $mode, $source),
IntakeOutcome::Link => [$decision, $this->link($block, $decision->booking, $decision->reasons[0] ?? '')],
IntakeOutcome::Clarify => [$decision, $this->flag($block, $decision->reasons[0] ?? '')],
default => [$decision, false],
};
}
$this->record($channel, $mode, $source, $decision, $applied, $block, null, $block->starts_on, $block->ends_on);
return $decision;
}
/**
* Takes over an existing portal entry by an explicit run of the landlord or operator (stock adoption), whatever the
* channel's switch says: certain bookings become cases (released by hand, never automatic), entries of known cases
* are linked, everything else is only reported.
*/
public function adopt(BlockedPeriod $block): IntakeDecision
{
$decision = $this->evaluate($block);
$applied = false;
if ($decision->outcome === IntakeOutcome::Create) {
[$decision, $applied] = $this->create($block, $decision, CaseIntakeMode::Create, IntakeObservation::SOURCE_ADOPTION);
} elseif ($decision->outcome === IntakeOutcome::Link) {
$applied = $this->link($block, $decision->booking, $decision->reasons[0] ?? '');
}
$this->record($block->channel, CaseIntakeMode::Create, IntakeObservation::SOURCE_ADOPTION, $decision, $applied, $block, null, $block->starts_on, $block->ends_on);
return $decision;
}
/**
* After a calendar sync: new or changed entries of the channel go through the intake; entries of known cases that
* disappeared or show other nights become reports on the case.
*/
public function afterSync(Channel $channel): void
{
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return;
}
$open = $channel->blockedPeriods()->whereIn('source', ['channel', 'email'])->whereNull('linked_booking_id')
->where('is_representation', false)->whereDate('ends_on', '>', CarbonImmutable::today())->orderBy('starts_on')->get();
foreach ($open as $block) {
$this->process($block, IntakeObservation::SOURCE_CALENDAR);
}
$linked = $channel->blockedPeriods()->withTrashed()->with('linkedBooking')->where('source', 'channel')->whereNotNull('linked_booking_id')
->whereHas('linkedBooking', fn ($query) => $query->whereIn('status', BookingStatus::occupying())->whereDate('departure', '>', CarbonImmutable::today()))->get();
foreach ($linked as $block) {
$case = $block->linkedBooking;
if ($block->trashed()) {
$this->report($channel, $mode, $case, IntakeOutcome::CancellationSignal, 'Der Eintrag '.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').' ist aus dem Kalender von '.$channel->name.' verschwunden. Das kann eine Stornierung sein, ist aber kein Nachweis – bitte im Portal prüfen.', 'gone:'.$block->id, IntakeObservation::SOURCE_CALENDAR, $block);
} elseif (! $block->starts_on->equalTo($case->arrival) || ! $block->ends_on->equalTo($case->departure)) {
$this->report($channel, $mode, $case, IntakeOutcome::ChangeSignal, 'Der Kalender von '.$channel->name.' meldet '.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').', der Vorgang hat '.$case->arrival->format('d.m.').'–'.$case->departure->format('d.m.Y').'. Bitte prüfen, ob die Buchung im Portal geändert wurde.', 'dates:'.$block->id.':'.$block->starts_on->toDateString().':'.$block->ends_on->toDateString(), IntakeObservation::SOURCE_CALENDAR, $block);
}
}
}
/**
* A portal e-mail reporting a cancellation: the case learns about it as a task; nothing is cancelled.
*
* @return Booking|null the case the report belongs to
*/
public function cancellationMail(Channel $channel, ParsedPortalMail $parsed, PortalEmail $mail): ?Booking
{
$case = $parsed->reference !== null ? $this->caseByReference($channel, $parsed->reference) : null;
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if ($case === null || ! $case->isBinding()) {
$this->record($channel, $mode, IntakeObservation::SOURCE_MAIL, new IntakeDecision(IntakeOutcome::Clarify, [$parsed->reference === null ? 'Stornierungsmail ohne Buchungsnummer – keinem Vorgang sicher zuzuordnen.' : 'Kein gebuchter Vorgang mit der Buchungsnummer '.$parsed->reference.'.'], reference: $parsed->reference), false, null, $mail, $parsed->startsOn, $parsed->endsOn);
return null;
}
$this->report($channel, $mode, $case, IntakeOutcome::CancellationSignal, $channel->name.' meldet eine Stornierung (E-Mail „'.$mail->subject.'“). Bitte prüfen Sie die Buchung und die nächsten Schritte.', 'mail:'.$mail->message_id, IntakeObservation::SOURCE_MAIL, null, $mail);
return $case;
}
/**
* A request e-mail of a portal: a request case with the dates and the reference (A2), when the channel creates
* cases; otherwise only recorded.
*/
public function inquiryMail(Channel $channel, ParsedPortalMail $parsed, PortalEmail $mail): IntakeDecision
{
$mode = $channel->case_intake ?? CaseIntakeMode::Off;
if (! $mode->records()) {
return new IntakeDecision(IntakeOutcome::Ignore, ['Automatische Übernahme ist für dieses Portal aus.']);
}
$profile = $this->settings->resolve($channel->property, $channel, IntakeKind::Inquiry);
$decision = match (true) {
! $parsed->hasPeriod() => new IntakeDecision(IntakeOutcome::Clarify, ['Anfrage erkannt, aber An- und Abreise nicht sicher lesbar.'], reference: $parsed->reference),
$parsed->reference !== null && ($case = $this->caseByReference($channel, $parsed->reference)) !== null => new IntakeDecision(IntakeOutcome::Link, ['Gleiche Anfragenummer '.$parsed->reference.' wie der Vorgang.'], $case, reference: $parsed->reference),
$parsed->endsOn->lessThanOrEqualTo(CarbonImmutable::today()) => new IntakeDecision(IntakeOutcome::Ignore, ['Liegt in der Vergangenheit.'], reference: $parsed->reference),
default => new IntakeDecision(IntakeOutcome::Inquiry, ['Anfrage-Mail von '.$channel->name.' mit Zeitraum.'], caseType: $profile->caseType, missing: ['Name und E-Mail-Adresse des Gastes', 'Personenzahl'], reference: $parsed->reference),
};
$applied = false;
if ($mode->creates() && $decision->outcome === IntakeOutcome::Inquiry) {
try {
$case = $this->inquiry->handle($channel, $parsed->startsOn, $parsed->endsOn, $parsed->reference, 'Automatisch aus der Anfrage-Mail von '.$channel->name.' übernommen („'.$mail->subject.'“).', $mode === CaseIntakeMode::Create ? ProcessingMode::Manual : null);
CaseLog::record($case, 'intake', 'Automatisch aus der Anfrage-Mail von '.$channel->name.' angelegt', actor: CaseLog::SYSTEM, data: ['source' => IntakeObservation::SOURCE_MAIL, 'message_id' => $mail->message_id]);
$decision = $decision->withBooking($case);
$applied = true;
} catch (ReservationException|QuoteException $exception) {
$decision = $decision->as(IntakeOutcome::Clarify, ['Anfrage nicht automatisch übernommen: '.$exception->getMessage()]);
}
}
$this->record($channel, $mode, IntakeObservation::SOURCE_MAIL, $decision, $applied, null, $mail, $parsed->startsOn, $parsed->endsOn);
return $decision;
}
/**
* The portal's booking reference of an entry: extracted by the calendar rules, or the one of a booking e-mail.
*/
public static function reference(BlockedPeriod $block): ?string
{
$fromRules = $block->ical_interpretation['fields']['booking_reference'] ?? null;
if (filled($fromRules)) {
return trim((string) $fromRules);
}
if ($block->source === 'email' && str_starts_with((string) $block->external_uid, 'email:')) {
$reference = substr((string) $block->external_uid, 6);
// Mails without a reference got a random identifier, which is no booking reference.
return preg_match('/^[0-9a-f]{32}$/', $reference) === 1 ? null : $reference;
}
return null;
}
/**
* The case of a portal booking with this reference: on the case itself or on an entry that belongs to a case.
*/
public function caseByReference(Channel $channel, string $reference): ?Booking
{
$case = Booking::query()->where('portal_reference', $reference)
->where(fn ($query) => $query->where('origin_channel_id', $channel->id)->orWhere('import_channel_id', $channel->id))
->orderBy('id')->first();
if ($case !== null) {
return $case;
}
$linked = $channel->blockedPeriods()->withTrashed()->whereNotNull('linked_booking_id')
->whereIn('external_uid', [$reference, 'email:'.$reference])->value('linked_booking_id');
return $linked !== null ? Booking::query()->find($linked) : null;
}
/**
* The one occupying case of this portal with exactly these nights (more than one: none – that is for a person).
*/
private function caseWithSameNights(BlockedPeriod $block, int $channelId): ?Booking
{
/** @var Collection<int, Booking> $cases */
$cases = Booking::query()->occupying()->where('property_id', $block->property_id)
->whereDate('arrival', $block->starts_on)->whereDate('departure', $block->ends_on)
->where(fn ($query) => $query->where('origin_channel_id', $channelId)->orWhere('import_channel_id', $channelId))
->get();
return $cases->count() === 1 ? $cases->first() : null;
}
/**
* Null when the entry is certainly a booking of its portal, otherwise why not.
*/
private function certainty(BlockedPeriod $block, ?string $reference): ?string
{
if ($block->needs_review && ! in_array($block->review_note, [ReconcileChannelRepresentations::OVERLAP_NOTE], true)) {
return 'Prüfhinweis am Eintrag: '.($block->review_note ?? 'bitte prüfen').'.';
}
if ($block->source === 'email') {
return $reference === null ? 'Buchungsmail ohne Buchungsnummer – ohne Nummer lässt sich ein späterer Kalendereintrag nicht sicher zuordnen.' : null;
}
// Classified by the landlord as a reservation booked at this portal.
if ($block->occupation_kind === OccupationKind::Reservation && $block->reviewed_at !== null && $block->origin_channel_id === $block->channel_id) {
return null;
}
$interpretation = (array) ($block->ical_interpretation ?? []);
if (! ($interpretation['matched'] ?? false)) {
return 'Kein Kalendermerkmal erkannt – eine reine Belegt-Meldung ist kein Nachweis einer Buchung.';
}
if (($interpretation['event_type'] ?? null) !== 'portal_reservation') {
return 'Die Regel „'.($interpretation['rule'] ?? '').'“ ordnet den Eintrag nicht als Buchung ein.';
}
if (($interpretation['representation'] ?? null) !== 'leading_candidate' || $block->origin_channel_id !== $block->channel_id) {
return 'Die Regel erkennt eine Reservierung, aber nicht sicher als Buchung bei diesem Portal.';
}
return null;
}
/**
* @return array{IntakeDecision, bool}
*/
private function create(BlockedPeriod $block, IntakeDecision $decision, CaseIntakeMode $mode, string $source): array
{
$channel = $block->channel;
$fields = (array) ($block->ical_interpretation['fields'] ?? []);
$name = trim((string) ($fields['guest_full_name'] ?? $fields['guest_first_name'] ?? ''));
$origin = match ($source) {
IntakeObservation::SOURCE_MAIL => 'der Buchungsmail',
IntakeObservation::SOURCE_ADOPTION => 'dem Bestand der Portalbelegungen',
default => 'dem Kalender',
};
try {
$case = $this->takeOver->handle($block->property, $channel, CarbonImmutable::parse($block->starts_on), CarbonImmutable::parse($block->ends_on), [
'portal_reference' => $decision->reference,
'notes' => 'Automatisch aus '.$origin.' von '.$channel->name.' übernommen.'.($name !== '' ? ' Name laut Portal: '.$name.'.' : ''),
'processing_mode' => $mode === CaseIntakeMode::Create ? ProcessingMode::Manual : null,
], $block);
} catch (ReservationException $exception) {
$this->flag($block, 'Nicht automatisch übernommen: '.$exception->getMessage());
return [$decision->as(IntakeOutcome::Clarify, ['Nicht automatisch übernommen: '.$exception->getMessage()]), false];
}
CaseLog::record($case, 'intake', 'Automatisch aus '.$origin.' von '.$channel->name.' angelegt', actor: CaseLog::SYSTEM, data: ['source' => $source, 'blocked_period_id' => $block->id, 'reference' => $decision->reference]);
return [$decision->withBooking($case), true];
}
/**
* Makes the entry a mirror of its case (the case leads availability and export).
*/
private function link(BlockedPeriod $block, ?Booking $case, string $reason): bool
{
if ($case === null || $block->linked_booking_id === $case->id || $block->is_representation) {
return false;
}
$block->forceFill([
'is_representation' => true, 'representation_automatic' => false, 'canonical_block_id' => null,
'linked_booking_id' => $case->id, 'export_approved' => false, 'needs_review' => false, 'reviewed_at' => now(),
'occupation_kind' => OccupationKind::Reservation, 'review_note' => self::LINK_NOTE,
])->save();
app(ReconcileChannelRepresentations::class)->handle($block->property);
CaseLog::record($case, 'intake', 'Weitere Quelle zugeordnet: '.($block->source === 'email' ? 'E-Mail' : 'Kalender').' von '.$block->channel?->name.' ('.$block->starts_on->format('d.m.').'–'.$block->ends_on->format('d.m.Y').')', $reason, actor: CaseLog::SYSTEM, data: ['blocked_period_id' => $block->id]);
return true;
}
/**
* Puts an uncertain entry in front of the landlord ("Zu erledigen") with the reason.
*/
private function flag(BlockedPeriod $block, string $reason): bool
{
if ($block->needs_review || $block->reviewed_at !== null) {
return false;
}
$block->forceFill(['needs_review' => true, 'review_note' => mb_substr($reason, 0, 250)])->saveQuietly();
return true;
}
/**
* A report of the portal about a known case: a task and an entry in the history – once per report.
*/
private function report(Channel $channel, CaseIntakeMode $mode, Booking $case, IntakeOutcome $outcome, string $message, string $key, string $source, ?BlockedPeriod $block = null, ?PortalEmail $mail = null): void
{
$fingerprint = hash('sha256', $channel->id.'|signal|'.$key);
$known = $case->events()->where('type', 'portal_signal')->get()->contains(fn ($event): bool => ($event->data['fingerprint'] ?? null) === $fingerprint);
$applied = false;
if ($mode->creates() && ! $known) {
$kind = $outcome === IntakeOutcome::CancellationSignal ? BookingTaskKind::PortalCancellationReported : BookingTaskKind::PortalChangeReported;
$task = BookingTask::query()->firstOrNew(['booking_id' => $case->id, 'kind' => $kind]);
$task->forceFill(['tenant_id' => $case->tenant_id, 'status' => BookingTaskStatus::Open, 'due_on' => today(), 'note' => mb_substr($message, 0, 1000), 'completed_by' => null, 'completed_at' => null])->save();
CaseLog::record($case, 'portal_signal', $message, actor: $channel->name, data: ['fingerprint' => $fingerprint, 'source' => $source]);
$applied = true;
}
$this->record($channel, $mode, $source, new IntakeDecision($outcome, [$message], $case, $case->case_type), $applied, $block, $mail, $block?->starts_on ?? $case->arrival, $block?->ends_on ?? $case->departure, $key);
}
/**
* Records the decision once per event and result (repeated syncs and mails add nothing).
*/
private function record(?Channel $channel, CaseIntakeMode $mode, string $source, IntakeDecision $decision, bool $applied, ?BlockedPeriod $block, ?PortalEmail $mail, mixed $startsOn, mixed $endsOn, ?string $key = null): void
{
if ($channel === null || ! $mode->records()) {
return;
}
$fingerprint = hash('sha256', implode('|', [
$channel->id, $mode->value, $decision->outcome->value, $key ?? '',
$block?->id ?? '', $mail?->message_id ?? '', $decision->booking?->id ?? '',
$startsOn instanceof \DateTimeInterface ? $startsOn->format('Y-m-d') : (string) $startsOn,
$endsOn instanceof \DateTimeInterface ? $endsOn->format('Y-m-d') : (string) $endsOn,
]));
try {
$observation = IntakeObservation::query()->firstOrNew(['fingerprint' => $fingerprint]);
if ($observation->exists) {
return;
}
$observation->fill([
'channel_id' => $channel->id, 'blocked_period_id' => $block?->id, 'portal_email_id' => $mail?->id,
'booking_id' => $decision->booking?->id, 'source' => $source, 'mode' => $mode, 'outcome' => $decision->outcome,
'applied' => $applied, 'case_type' => $decision->caseType?->value, 'reference' => $decision->reference,
'starts_on' => $startsOn, 'ends_on' => $endsOn, 'reasons' => $decision->reasons, 'missing' => $decision->missing,
'occurred_at' => now(),
]);
$observation->tenant_id = $channel->tenant_id;
$observation->save();
} catch (Throwable $exception) {
// The record must never stop the intake itself.
report($exception);
}
}
}
+159
View File
@@ -0,0 +1,159 @@
<?php
namespace App\Console\Commands;
use App\Enums\BookingStatus;
use App\Enums\IntakeKind;
use App\Enums\InternalKind;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\Tenant;
use App\Process\CaseLog;
use App\Process\ProcessSettings;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
#[Signature('cases:adopt-blocks
{--apply : Wirklich übernehmen (ohne: nur Vorschau)}
{--revert= : Eine frühere Übernahme anhand ihres Berichts zurücknehmen}')]
#[Description('Bisherige manuelle Sperren als A6-Vorgänge übernehmen (Vorschau, Bericht, wiederholbar, rücknehmbar); der Kalenderexport für die Portale bleibt gleich')]
class AdoptManualBlocks extends Command
{
private const DIRECTORY = 'block-adoptions';
private const ADOPTED = 'übernommen';
public function handle(TenantRunner $runner, ProcessSettings $settings): int
{
if (filled($this->option('revert'))) {
return $this->revert((string) $this->option('revert'));
}
$apply = (bool) $this->option('apply');
$report = ['run' => now()->format('Ymd-His'), 'apply' => $apply, 'entries' => []];
$succeeded = $runner->each(function (Tenant $tenant) use ($apply, $settings, &$report): void {
$blocks = BlockedPeriod::query()->with(['property', 'guest'])->where('source', 'manual')->whereNull('linked_booking_id')->orderBy('starts_on')->get();
foreach ($blocks as $block) {
$kind = $block->guest_id !== null ? InternalKind::PrivateStay : InternalKind::fromPurpose($block->block_purpose);
$entry = [
'tenant' => $tenant->id, 'blocked_period_id' => $block->id, 'property' => $block->property?->name,
'period' => $block->starts_on->format('d.m.Y').'–'.$block->ends_on->format('d.m.Y'), 'kind' => $kind->value,
'occasion' => $block->block_note ?: $block->reason, 'booking_id' => null, 'result' => 'neu',
];
if (Booking::query()->where('export_uid', 'block-'.$block->id)->exists()) {
$entry['result'] = 'schon übernommen';
} elseif (Booking::query()->occupying()->where('property_id', $block->property_id)->overlapping($block->starts_on, $block->ends_on)->exists()) {
$entry['result'] = 'unklar: überschneidet sich mit einem Vorgang – nicht übernommen';
} elseif ($apply) {
$entry['booking_id'] = $this->adopt($block, $kind, $settings)->id;
$entry['result'] = self::ADOPTED;
}
$report['entries'][] = $entry;
}
});
$this->table(['Wohnung', 'Zeitraum', 'Art', 'Anlass', 'Ergebnis', 'Vorgang'], array_map(fn (array $entry): array => [
$entry['property'], $entry['period'], InternalKind::from($entry['kind'])->getLabel(), $entry['occasion'], $entry['result'], $entry['booking_id'] ? '#'.$entry['booking_id'] : '–',
], $report['entries']));
$suffix = $apply ? '' : '-vorschau';
$path = self::DIRECTORY.'/'.$report['run'].$suffix.'.json';
for ($number = 2; Storage::disk('local')->exists($path); $number++) {
$path = self::DIRECTORY.'/'.$report['run'].$suffix.'-'.$number.'.json';
}
Storage::disk('local')->put($path, json_encode($report, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
$counts = collect($report['entries'])->countBy('result')->map(fn (int $count, string $result): string => $result.' '.$count)->implode(', ');
$this->info(($apply ? 'Übernommen' : 'Vorschau – nichts geändert').': '.($counts ?: 'keine manuellen Sperren'));
$this->line('Bericht: storage/app/private/'.$path.($apply ? ' (Rücknahme: --revert='.$path.')' : ''));
if ($succeeded < $runner->tenants()->count()) {
$this->error('Bei mindestens einem Vermieter ist ein Fehler aufgetreten – Details im Protokoll (storage/logs).');
return self::FAILURE;
}
return self::SUCCESS;
}
/**
* The block becomes a case without any side effect: no portal tasks and no mails (the portals have the dates
* already), the same export identity and time stamp; the block is kept (deleted softly) for a revert.
*/
private function adopt(BlockedPeriod $block, InternalKind $kind, ProcessSettings $settings): Booking
{
return DB::transaction(function () use ($block, $kind, $settings): Booking {
$profile = $settings->resolve($block->property, null, IntakeKind::Internal)->withOrigin('migration');
$booking = Model::withoutEvents(function () use ($block, $kind, $profile): Booking {
$booking = new Booking([
'status' => BookingStatus::Confirmed, 'source' => 'internal', 'intake' => IntakeKind::Internal, 'internal_kind' => $kind,
'occasion' => $block->block_note ?: $block->reason, 'arrival' => $block->starts_on->toDateString(), 'departure' => $block->ends_on->toDateString(),
'export_uid' => 'block-'.$block->id, 'confirmed_at' => $block->created_at,
]);
$booking->forceFill([
'tenant_id' => $block->tenant_id, 'property_id' => $block->property_id, 'guest_id' => $block->guest_id,
'case_type' => $profile->caseType, 'profile' => $profile->toArray(),
'created_at' => $block->created_at, 'updated_at' => $block->updated_at,
]);
$booking->timestamps = false;
$booking->save();
// Dates are only cast while timestamps are on; the reference counts by the year of creation.
$booking->timestamps = true;
$reference = $booking->refresh()->nextReference();
$booking->timestamps = false;
$booking->forceFill(['reference' => $reference])->save();
$block->forceFill(['linked_booking_id' => $booking->id, 'review_note' => 'In Vorgang übernommen (A6).'])->saveQuietly();
$block->deleteQuietly();
return $booking;
});
CaseLog::record($booking, 'intake', 'Aus der bisherigen Sperrzeitenliste übernommen'.($booking->occasion ? ': '.$booking->occasion : ''), actor: CaseLog::SYSTEM, data: ['blocked_period_id' => $block->id]);
return $booking;
});
}
/**
* Takes an adoption back: the block comes back as it was and the case created by the run goes – unless somebody has
* worked on the case since (then it is reported and kept).
*/
private function revert(string $path): int
{
if (! Storage::disk('local')->exists($path)) {
$this->error('Bericht nicht gefunden: '.$path);
return self::FAILURE;
}
$report = json_decode((string) Storage::disk('local')->get($path), true);
$kept = [];
foreach ((array) ($report['entries'] ?? []) as $entry) {
if (($entry['result'] ?? null) !== self::ADOPTED) {
continue;
}
$booking = Booking::query()->withoutGlobalScopes()->find($entry['booking_id']);
if ($booking !== null && $booking->events()->where('type', '!=', 'intake')->exists()) {
$kept[] = $booking->reference;
continue;
}
Model::withoutEvents(function () use ($entry, $booking): void {
$block = BlockedPeriod::query()->withoutGlobalScopes()->withTrashed()->find($entry['blocked_period_id']);
$block?->forceFill(['linked_booking_id' => null, 'review_note' => null, 'deleted_at' => null])->saveQuietly();
$booking?->delete();
});
}
$this->info('Zurückgenommen.'.($kept === [] ? '' : ' Nicht entfernt, weil seitdem bearbeitet: '.implode(', ', $kept)));
return self::SUCCESS;
}
}
@@ -0,0 +1,129 @@
<?php
namespace App\Console\Commands;
use App\Channels\Intake\PortalIntake;
use App\Enums\ChannelTaskStatus;
use App\Enums\IntakeOutcome;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\Channel;
use App\Models\ChannelTask;
use App\Models\Tenant;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Storage;
#[Signature('channels:adopt-occupations
{--channel=* : Nur diese Kanal-IDs}
{--apply : Wirklich übernehmen (ohne: nur Vorschau)}
{--revert= : Eine frühere Übernahme anhand ihres Berichts zurücknehmen}')]
#[Description('Bestehende Portalbelegungen ohne Vorgang prüfen und – nur mit --apply – als Vorgang übernehmen bzw. dem vorhandenen Vorgang zuordnen (Bericht, wiederholbar, rücknehmbar)')]
class AdoptPortalOccupations extends Command
{
private const DIRECTORY = 'intake-adoptions';
/** Attributes of an entry that an adoption changes and a revert restores. */
private const RESTORED = ['is_representation', 'representation_automatic', 'canonical_block_id', 'linked_booking_id', 'export_approved', 'needs_review', 'reviewed_at', 'occupation_kind', 'guest_id', 'review_note'];
public function handle(TenantRunner $runner, PortalIntake $intake): int
{
if (filled($this->option('revert'))) {
return $this->revert((string) $this->option('revert'));
}
$apply = (bool) $this->option('apply');
$report = ['run' => now()->format('Ymd-His'), 'apply' => $apply, 'entries' => [], 'channel_task_ids' => []];
$firstTask = (int) ChannelTask::query()->withoutGlobalScopes()->max('id');
$succeeded = $runner->each(function (Tenant $tenant) use ($intake, $apply, &$report): void {
$channels = Channel::query()->when($this->option('channel'), fn ($query, $ids) => $query->whereKey($ids))->orderBy('id')->get();
foreach ($channels as $channel) {
$entries = $channel->blockedPeriods()->whereIn('source', ['channel', 'email'])->whereNull('linked_booking_id')
->where('is_representation', false)->whereDate('ends_on', '>', today())->orderBy('starts_on')->get();
foreach ($entries as $entry) {
$before = collect(self::RESTORED)->mapWithKeys(fn (string $field): array => [$field => $entry->getRawOriginal($field)])->all();
$decision = $apply ? $intake->adopt($entry) : $intake->evaluate($entry);
$created = $apply && $decision->outcome === IntakeOutcome::Create && $decision->booking !== null;
$report['entries'][] = [
'tenant' => $tenant->id, 'channel' => $channel->name, 'blocked_period_id' => $entry->id,
'period' => $entry->starts_on->format('d.m.Y').'–'.$entry->ends_on->format('d.m.Y'),
'outcome' => $decision->outcome->value, 'case_type' => $decision->caseType?->value, 'reference' => $decision->reference,
'booking_id' => $decision->booking?->id, 'created' => $created, 'reasons' => $decision->reasons, 'before' => $before,
];
}
}
});
if ($apply) {
$report['channel_task_ids'] = ChannelTask::query()->withoutGlobalScopes()->where('id', '>', $firstTask)->pluck('id')->all();
}
$this->table(['Kanal', 'Zeitraum', 'Ergebnis', 'Art', 'Nr.', 'Vorgang', 'Begründung'], array_map(fn (array $entry): array => [
$entry['channel'], $entry['period'], IntakeOutcome::from($entry['outcome'])->getLabel(), strtoupper((string) $entry['case_type']), $entry['reference'] ?? '–',
$entry['booking_id'] ? '#'.$entry['booking_id'].($entry['created'] ? ' (neu)' : '') : '–', implode(' ', $entry['reasons']),
], $report['entries']));
$path = self::DIRECTORY.'/'.$report['run'].($apply ? '' : '-vorschau').'.json';
for ($number = 2; Storage::disk('local')->exists($path); $number++) {
$path = self::DIRECTORY.'/'.$report['run'].($apply ? '' : '-vorschau').'-'.$number.'.json';
}
Storage::disk('local')->put($path, json_encode($report, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
$counts = collect($report['entries'])->countBy('outcome');
$this->info(($apply ? 'Übernommen' : 'Vorschau – nichts geändert').': '.$counts->map(fn (int $count, string $outcome): string => IntakeOutcome::from($outcome)->getLabel().' '.$count)->implode(', '));
$this->line('Bericht: storage/app/private/'.$path.($apply ? ' (Rücknahme: --revert='.$path.')' : ''));
if ($succeeded < $runner->tenants()->count()) {
$this->error('Bei mindestens einem Vermieter ist ein Fehler aufgetreten – Details im Protokoll (storage/logs).');
return self::FAILURE;
}
return self::SUCCESS;
}
/**
* Takes an adoption back: cases created by it are removed again as long as nothing has happened with them (no
* document, no payment), and every entry gets its former state. Cases with activity are reported, not touched.
*/
private function revert(string $path): int
{
if (! Storage::disk('local')->exists($path)) {
$this->error('Bericht nicht gefunden: '.$path);
return self::FAILURE;
}
$report = json_decode((string) Storage::disk('local')->get($path), true);
if (! ($report['apply'] ?? false)) {
$this->info('Das war eine Vorschau – es gibt nichts zurückzunehmen.');
return self::SUCCESS;
}
$kept = [];
foreach ((array) $report['entries'] as $entry) {
$block = BlockedPeriod::query()->withoutGlobalScopes()->withTrashed()->find($entry['blocked_period_id']);
$case = ($entry['created'] ?? false) ? Booking::query()->withoutGlobalScopes()->find($entry['booking_id']) : null;
if ($case !== null && ($case->contract_path !== null || $case->confirmation_sent_at !== null || $case->payments()->withoutGlobalScopes()->exists())) {
$kept[] = $case->reference;
continue;
}
// The entry first gets its former state (it may point to the case), then the case created by the run goes.
if ($block !== null && in_array($entry['outcome'], [IntakeOutcome::Create->value, IntakeOutcome::Link->value], true)) {
$block->forceFill((array) $entry['before'])->saveQuietly();
}
$case?->delete();
}
ChannelTask::query()->withoutGlobalScopes()->whereKey((array) ($report['channel_task_ids'] ?? []))->where('status', ChannelTaskStatus::Open)
->update(['status' => ChannelTaskStatus::Dismissed, 'automation_error' => 'Bestandsübernahme zurückgenommen.']);
$this->info('Zurückgenommen.'.($kept === [] ? '' : ' Nicht entfernt, weil schon bearbeitet: '.implode(', ', $kept)));
return self::SUCCESS;
}
}
+41
View File
@@ -0,0 +1,41 @@
<?php
namespace App\Console\Commands;
use App\Enums\IntakeOutcome;
use App\Models\IntakeObservation;
use App\Models\Tenant;
use App\Tenancy\TenantRunner;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
#[Signature('channels:intake-report {--days=14 : Zeitraum in Tagen}')]
#[Description('Bericht des Eingangsprotokolls: was über die Portale hereinkam und welche Vorgänge entstanden sind oder entstanden wären')]
class IntakeReport extends Command
{
public function handle(TenantRunner $runner): int
{
$runner->each(function (Tenant $tenant): void {
$observations = IntakeObservation::query()->with(['channel', 'booking'])
->where('occurred_at', '>=', now()->subDays((int) $this->option('days')))->orderBy('occurred_at')->get();
$this->line("<options=bold>{$tenant->name}</>: ".$observations->count().' Einträge');
$this->table(['Wann', 'Portal', 'Quelle', 'Zeitraum', 'Ergebnis', 'Ausgeführt', 'Vorgang', 'Begründung'], $observations->map(fn (IntakeObservation $observation): array => [
$observation->occurred_at->format('d.m. H:i'),
$observation->channel?->name,
$observation->sourceLabel(),
$observation->starts_on ? $observation->starts_on->format('d.m.').'–'.$observation->ends_on?->format('d.m.Y') : '–',
$observation->outcome->getLabel(),
$observation->applied ? 'ja' : 'nur protokolliert',
$observation->booking?->reference ?? '–',
implode(' ', (array) $observation->reasons),
])->all());
$wouldCreate = $observations->filter(fn (IntakeObservation $observation): bool => ! $observation->applied && in_array($observation->outcome, [IntakeOutcome::Create, IntakeOutcome::Inquiry], true))->count();
$this->info("Wären entstanden (Beobachten): {$wouldCreate}");
});
return self::SUCCESS;
}
}
+2
View File
@@ -25,6 +25,8 @@ public function handle(): int
$this->line("Versandweg: {$mailer}".($mailer === 'smtp' ? ' ('.config('mail.mailers.smtp.host').':'.config('mail.mailers.smtp.port').')' : '').' · Absender: '.config('mail.from.address'));
if (filled($redirect)) {
$this->line("Umleitung aktiv: die Mail geht an {$redirect} statt an {$to}.");
} elseif (! Settings::isLive()) {
$this->warn('Testbetrieb ohne Testadresse: Es wird keine E-Mail versendet. Testempfänger unter System › Betrieb eintragen.');
}
if ($mailer === 'log') {
$this->warn('Versandweg "log": es wird nichts zugestellt. Zum echten Versand MAIL_MAILER=smtp und MAIL_PASSWORD setzen (docs/BETRIEB.md §5a).');
+1
View File
@@ -62,6 +62,7 @@ public function compose(Booking $booking, ?DocumentKind $kind = null, array $cha
$frozen = $kind !== DocumentKind::Offer && ($booking->contract_path !== null || ($booking->offer_version > 0 && is_array($booking->offer_terms)));
$explicitTemplate = ! $frozen && filled($changes['contract_template_id'] ?? null);
$template = match (true) {
$kind === DocumentKind::StayConfirmation => null,
$frozen => isset($booking->offer_terms['template']['id']) ? ContractTemplate::query()->find($booking->offer_terms['template']['id']) : null,
default => OfferTerms::templateFor($booking, $explicitTemplate ? $changes['contract_template_id'] : null),
};
+44
View File
@@ -0,0 +1,44 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* A stated amount of a case as a portal or another source shows it (package 8, K01): stored as stated, never derived.
* Positions of the guest's price, what the landlord pays the portal, and what the portal announces to pay out stay
* apart; an unexplained collective amount stays unexplained.
*/
enum AmountKind: string implements HasLabel
{
case Accommodation = 'accommodation';
case Service = 'service';
case Discount = 'discount';
case Fee = 'fee';
case Unexplained = 'unexplained';
case Commission = 'commission';
case PayoutAnnounced = 'payout_announced';
case InstallmentDue = 'installment_due';
public function getLabel(): string
{
return match ($this) {
self::Accommodation => 'Übernachtung',
self::Service => 'Leistung / Zusatzleistung',
self::Discount => 'Rabatt (mit Minus)',
self::Fee => 'Gebühr oder Steuer',
self::Unexplained => 'Sammelposten, nicht aufgeschlüsselt',
self::Commission => 'Provision / an das Portal gezahlt',
self::PayoutAnnounced => 'Angekündigte Auszahlung an uns',
self::InstallmentDue => 'Rate des Gastes laut Portal fällig',
};
}
/**
* Whether the amount is part of the guest's price (and adds up to the guest total).
*/
public function isPricePosition(): bool
{
return in_array($this, [self::Accommodation, self::Service, self::Discount, self::Fee, self::Unexplained], true);
}
}
+8 -2
View File
@@ -17,6 +17,9 @@ enum BookingTaskKind: string implements HasLabel
case CancellationRequest = 'cancellation_request';
case CancellationFee = 'cancellation_fee';
case PortalCancellation = 'portal_cancellation';
case PortalCancellationReported = 'portal_cancel_reported';
case PortalChangeReported = 'portal_change_reported';
case RefundCheck = 'refund_check';
public function getLabel(): string
{
@@ -27,12 +30,15 @@ public function getLabel(): string
self::CancellationRequest => 'Stornierungswunsch des Gastes',
self::CancellationFee => 'Stornokosten prüfen und abrechnen',
self::PortalCancellation => 'Stornierung im Portal veranlassen bzw. prüfen',
self::PortalCancellationReported => 'Das Portal meldet eine Stornierung – bitte prüfen',
self::PortalChangeReported => 'Das Portal meldet eine Änderung – bitte prüfen',
self::RefundCheck => 'Erstattung an den Gast prüfen',
};
}
public function isPayment(): bool
{
return ! in_array($this, [self::CancellationRequest, self::CancellationFee, self::PortalCancellation], true);
return ! in_array($this, [self::CancellationRequest, self::CancellationFee, self::PortalCancellation, self::PortalCancellationReported, self::PortalChangeReported, self::RefundCheck], true);
}
/**
@@ -46,7 +52,7 @@ public function reminder(): ?array
self::DepositReminder => [PaymentReminder::DEPOSIT_OVERDUE, 'deposit_reminded_at'],
self::BalanceRequest => [PaymentReminder::BALANCE_REQUEST, 'balance_requested_at'],
self::BalanceReminder => [PaymentReminder::BALANCE_OVERDUE, 'balance_reminded_at'],
self::CancellationRequest, self::CancellationFee, self::PortalCancellation => null,
self::CancellationRequest, self::CancellationFee, self::PortalCancellation, self::PortalCancellationReported, self::PortalChangeReported, self::RefundCheck => null,
};
}
}
+50
View File
@@ -0,0 +1,50 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasDescription;
use Filament\Support\Contracts\HasLabel;
/**
* Whether bookings and requests recognised on a channel become cases by themselves (UMSETZUNGSPLAN_v0.10 §5.5). Every
* channel starts switched off; observing only records what would happen. Creating cases never sends anything that the
* landlord has not released (documents need their release, package 3); only the last mode lets the new cases follow
* the automatic handling of the settings.
*/
enum CaseIntakeMode: string implements HasDescription, HasLabel
{
case Off = 'off';
case Observe = 'observe';
case Create = 'create';
case Continue = 'continue';
public function getLabel(): string
{
return match ($this) {
self::Off => 'Aus – Sie übernehmen Buchungen selbst',
self::Observe => 'Beobachten – nur protokollieren, was entstehen würde',
self::Create => 'Vorgänge anlegen – die nächsten Schritte geben Sie frei',
self::Continue => 'Vorgänge anlegen und nach Ihren Einstellungen weiterbearbeiten',
};
}
public function getDescription(): string
{
return match ($this) {
self::Off => 'Erkannte Buchungen erscheinen als Klärungsfall; nichts entsteht automatisch.',
self::Observe => 'Es entsteht nichts. Das Eingangsprotokoll zeigt, welche Vorgänge entstanden wären und warum.',
self::Create => 'Sicher erkannte Buchungen werden zum Vorgang; Sie geben jeden weiteren Schritt frei.',
self::Continue => 'Wie „anlegen“; danach laufen die Vorgänge automatisch oder mit Freigabe – wie unter „So arbeite ich“ eingestellt.',
};
}
public function records(): bool
{
return $this !== self::Off;
}
public function creates(): bool
{
return in_array($this, [self::Create, self::Continue], true);
}
}
+31
View File
@@ -0,0 +1,31 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* How a change of a booking was agreed with the guest – the evidence the case keeps (package 5). Sending an updated
* confirmation is none of these: it informs the guest, it does not show the guest's consent.
*/
enum ChangeBasis: string implements HasLabel
{
case Phone = 'phone';
case Email = 'email';
case InPerson = 'in_person';
case Portal = 'portal';
case GuestLink = 'guest_link';
case NotNeeded = 'not_needed';
public function getLabel(): string
{
return match ($this) {
self::Phone => 'am Telefon vereinbart',
self::Email => 'per E-Mail / schriftlich vereinbart',
self::InPerson => 'persönlich vereinbart',
self::Portal => 'im Portal geändert',
self::GuestLink => 'vom Gast über den Link angenommen',
self::NotNeeded => 'keine Zustimmung nötig (eigener Vorgang)',
};
}
}
+41
View File
@@ -0,0 +1,41 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasColor;
use Filament\Support\Contracts\HasLabel;
enum ChangeStatus: string implements HasColor, HasLabel
{
/** Sent to the guest, waiting for the guest's answer; nothing has changed yet. */
case Proposed = 'proposed';
/** In force. */
case Applied = 'applied';
case Declined = 'declined';
case Withdrawn = 'withdrawn';
case Expired = 'expired';
public function getLabel(): string
{
return match ($this) {
self::Proposed => 'dem Gast vorgeschlagen',
self::Applied => 'wirksam',
self::Declined => 'vom Gast abgelehnt',
self::Withdrawn => 'zurückgezogen',
self::Expired => 'nicht beantwortet',
};
}
public function getColor(): string
{
return match ($this) {
self::Proposed => 'warning',
self::Applied => 'success',
default => 'gray',
};
}
}
+54
View File
@@ -0,0 +1,54 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasColor;
use Filament\Support\Contracts\HasLabel;
/**
* How far a block (or release) on a portal is proven (E-018). The three steps are different statements: entering the
* block does not show that the portal took it over, and a calendar feed we provide proves nothing about the portal.
*/
enum ChannelTaskProof: string implements HasColor, HasLabel
{
/** The change was made or started (by hand or by an automation). */
case Initiated = 'initiated';
/** The block was seen in the portal's own calendar. */
case Observed = 'observed';
/** The portal confirmed it (e.g. its own confirmation or a test booking was refused). */
case Confirmed = 'confirmed';
public function getLabel(): string
{
return match ($this) {
self::Initiated => 'veranlasst',
self::Observed => 'im Portal gesehen',
self::Confirmed => 'Wirksamkeit bestätigt',
};
}
public function getColor(): string
{
return match ($this) {
self::Initiated => 'warning',
self::Observed => 'info',
self::Confirmed => 'success',
};
}
/**
* The choice the landlord reads when completing a task.
*/
public function question(bool $block = true): string
{
$what = $block ? 'gesperrt' : 'freigegeben';
return match ($this) {
self::Initiated => "Ich habe den Zeitraum im Portal {$what}.",
self::Observed => "… und im Kalender des Portals gesehen, dass er {$what} ist.",
self::Confirmed => 'Das Portal hat es bestätigt (z. B. Bestätigung oder Testanfrage abgelehnt).',
};
}
}
+2 -2
View File
@@ -43,7 +43,7 @@ public function description(): string
self::Information => 'Für Anfragen ohne Reservierung: Preis und Verfügbarkeit ohne Zusage; der Gast kann die Buchung anfragen. Folgt mit Paket 7.',
self::Confirmation => 'Nach der Annahme eines Angebots oder einer direkt vereinbarten Buchung: Bestätigung mit dem Mietvertrag.',
self::ExternalRecord => 'Für Buchungen, die beim Portal bereits verbindlich sind: Buchungsdaten und – falls hinterlegt – Ihre Vorlage, ohne erneute Annahme durch den Gast.',
self::StayConfirmation => 'Für private Überlassungen (Familie, Freunde): Bestätigung des Aufenthalts ohne Mietvertrag. Folgt mit Paket 6.',
self::StayConfirmation => 'Für private Überlassungen (Familie, Freunde): Bestätigung des Aufenthalts ohne Mietvertrag, nur auf Wunsch.',
self::Internal => 'Eigennutzung und Wartung: kein Dokument an Gäste.',
};
}
@@ -84,7 +84,7 @@ public function containsContract(): bool
*/
public function isAvailable(): bool
{
return in_array($this, [self::Offer, self::Confirmation, self::ExternalRecord], true);
return in_array($this, [self::Offer, self::Confirmation, self::ExternalRecord, self::StayConfirmation], true);
}
/**
+56
View File
@@ -0,0 +1,56 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasColor;
use Filament\Support\Contracts\HasLabel;
/**
* What the intake made of one incoming event (portal calendar entry or portal e-mail).
*/
enum IntakeOutcome: string implements HasColor, HasLabel
{
/** A booking binding on the portal, recognised with confidence: a new case (A3–A5). */
case Create = 'create';
/** A non-binding request through the portal: a new request case (A2). */
case Inquiry = 'inquiry';
/** The same booking as an existing case (reference, same portal and dates, or its calendar mirror). */
case Link = 'link';
/** Not certain enough: the landlord clarifies. */
case Clarify = 'clarify';
/** No booking of this portal (block, mirror of another portal, own use, already clarified). */
case Ignore = 'ignore';
/** The portal reports a cancellation of a known case. */
case CancellationSignal = 'cancellation';
/** The portal reports other dates for a known case, or its calendar entry disappeared. */
case ChangeSignal = 'change';
public function getLabel(): string
{
return match ($this) {
self::Create => 'Neuer Vorgang (Buchung)',
self::Inquiry => 'Neuer Vorgang (Anfrage)',
self::Link => 'Gehört zu vorhandenem Vorgang',
self::Clarify => 'Klärung nötig',
self::Ignore => 'Keine Buchung',
self::CancellationSignal => 'Portal meldet Stornierung',
self::ChangeSignal => 'Portal meldet Änderung',
};
}
public function getColor(): string
{
return match ($this) {
self::Create, self::Inquiry => 'success',
self::Link, self::Ignore => 'gray',
self::Clarify => 'warning',
self::CancellationSignal, self::ChangeSignal => 'danger',
};
}
}
+35
View File
@@ -0,0 +1,35 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* The kinds of internal cases (A6): the landlord's own use, a private stay of family or friends, or a block without a
* guest (maintenance and the like). None of them has a rental contract, payment reminders, reviews or marketing.
*/
enum InternalKind: string implements HasLabel
{
case OwnUse = 'own_use';
case PrivateStay = 'private_stay';
case Block = 'block';
public function getLabel(): string
{
return match ($this) {
self::OwnUse => 'Eigene Nutzung',
self::PrivateStay => 'Private Überlassung (Familie, Freunde)',
self::Block => 'Sperre (z. B. Wartung)',
};
}
public function hasGuests(): bool
{
return $this === self::PrivateStay;
}
public static function fromPurpose(?BlockedPeriodPurpose $purpose): self
{
return $purpose === BlockedPeriodPurpose::OwnUse ? self::OwnUse : self::Block;
}
}
+51
View File
@@ -0,0 +1,51 @@
<?php
namespace App\Enums;
use Filament\Support\Contracts\HasLabel;
/**
* What a payment is (package 8): only the guest's payments count towards what the guest owes; a portal's payout is
* money on our account but no payment of the guest, and "paid to the portal" is the portal's statement, not money we
* received. Nothing is counted twice.
*/
enum PaymentKind: string implements HasLabel
{
/** The guest paid us (transfer, cash). */
case Guest = 'guest';
/** The portal reports that the guest paid it (no money on our account). */
case GuestViaPortal = 'guest_via_portal';
/** The portal paid out to us. */
case PortalPayout = 'portal_payout';
/** We paid money back to the guest (entered as a positive amount, counted negative). */
case Refund = 'refund';
public function getLabel(): string
{
return match ($this) {
self::Guest => 'Gast hat an uns gezahlt',
self::GuestViaPortal => 'Gast hat laut Portal ans Portal gezahlt',
self::PortalPayout => 'Auszahlung vom Portal erhalten',
self::Refund => 'Erstattung an den Gast',
};
}
/**
* Whether it counts towards what the guest has paid of the agreed total.
*/
public function countsAsGuestPayment(): bool
{
return $this !== self::PortalPayout;
}
/**
* Whether the money moved through our account.
*/
public function isOnOurAccount(): bool
{
return $this !== self::GuestViaPortal;
}
}
+7 -1
View File
@@ -13,11 +13,17 @@ enum QuoteLineType: string
/** Manual price change by the landlord in an offer (negative = reduction). */
case Adjustment = 'adjustment';
/** The agreed rent of an internal case (A6), e.g. 0 for family. */
case Rent = 'rent';
/** The tourist tax (Kurabgabe) as its own position: persons × nights × the landlord's rate. */
case TouristTax = 'tourist_tax';
/**
* Whether the line counts towards the rent on which the deposit is calculated.
*/
public function isRent(): bool
{
return in_array($this, [self::Accommodation, self::ExtraGuest, self::Discount, self::Adjustment], true);
return in_array($this, [self::Accommodation, self::ExtraGuest, self::Discount, self::Adjustment, self::Rent], true);
}
}
+4
View File
@@ -12,11 +12,15 @@ enum Responsibility: string implements HasLabel
case Landlord = 'landlord';
case Portal = 'portal';
/** Nobody: internal cases (A6) have no rental documents, payment reminders or guest mails. */
case Nobody = 'none';
public function getLabel(): string
{
return match ($this) {
self::Landlord => 'Wir',
self::Portal => 'Das Portal',
self::Nobody => 'Entfällt',
};
}
}
@@ -10,6 +10,7 @@
use App\Mail\BookingConfirmed;
use App\Mail\BookingDocumentation;
use App\Mail\OfferMade;
use App\Mail\StayConfirmed;
use App\Models\Booking;
use App\Models\User;
use Closure;
@@ -86,6 +87,7 @@ private static function mailPreview(DocumentComposition $composition): string
return match ($composition->kind) {
DocumentKind::Offer => (new OfferMade($draft, '#'))->render(),
DocumentKind::ExternalRecord => (new BookingDocumentation($draft))->render(),
DocumentKind::StayConfirmation => (new StayConfirmed($draft))->render(),
default => (new BookingConfirmed($draft))->render(),
};
} catch (Throwable $exception) {
+1 -1
View File
@@ -36,7 +36,7 @@ public static function field(string $name, ProcessSetting $setting, string $inhe
->helperText('Automatisch: Das System sendet Angebote bzw. Unterlagen selbst, sobald alle Angaben da sind. Sonst bereitet es alles vor und Sie geben frei.'),
ProcessSetting::PreReservation => Select::make($name)->options(['1' => 'Ja – der Zeitraum ist bis zum Ablauf des Angebots reserviert', '0' => 'Nein – eine Anfrage reserviert nichts'])->placeholder($placeholder),
ProcessSetting::HoldHours => TextInput::make($name)->integer()->minValue(1)->maxValue(720)->suffix('Stunden')->placeholder($placeholder),
ProcessSetting::Documents, ProcessSetting::Payments, ProcessSetting::GuestMessages => Select::make($name)->options(Responsibility::class)->placeholder($placeholder),
ProcessSetting::Documents, ProcessSetting::Payments, ProcessSetting::GuestMessages => Select::make($name)->options([Responsibility::Landlord->value => Responsibility::Landlord->getLabel(), Responsibility::Portal->value => Responsibility::Portal->getLabel()])->placeholder($placeholder),
ProcessSetting::ArrivalInfoDaysBefore => TextInput::make($name)->integer()->minValue(1)->maxValue(14)->suffix('Tage vor Anreise')->placeholder($placeholder),
ProcessSetting::ContractTemplate => Select::make($name)
->options(fn (): array => ContractTemplate::query()->orderBy('name')->orderBy('version')->get()->mapWithKeys(fn (ContractTemplate $template): array => [$template->id => $template->label()])->all())
+120
View File
@@ -0,0 +1,120 @@
<?php
namespace App\Filament\Pages;
use App\Enums\IntakeKind;
use App\Enums\ProcessSetting;
use App\Enums\UserRole;
use App\Filament\Concerns\FollowsAdminMode;
use App\Models\Booking;
use App\Models\Channel;
use App\Models\ContractTemplate;
use App\Models\Property;
use App\Process\ProcessProfile;
use App\Process\ProcessSettings;
use BackedEnum;
use Filament\Pages\Page;
use Filament\Support\Icons\Heroicon;
use UnitEnum;
/**
* "Wirksame Einstellungen" (expert view, KONFIGURATION_UND_WIRKSAMKEIT): for every property, every way a case can come
* in (direct request, each portal for requests and for binding bookings, own use) the value of every process setting
* that applies right now and the level it comes from – and for one chosen case the profile that really was applied.
* Read only: settings are changed where they belong ("So arbeite ich", the property, the portal).
*/
class EffectiveSettings extends Page
{
use FollowsAdminMode;
protected static string|BackedEnum|null $navigationIcon = Heroicon::OutlinedAdjustmentsHorizontal;
protected static string|UnitEnum|null $navigationGroup = 'System';
protected static ?string $navigationLabel = 'Wirksame Einstellungen';
protected static ?string $title = 'Wirksame Einstellungen';
protected static ?string $slug = 'wirksame-einstellungen';
protected static ?int $navigationSort = 3;
protected string $view = 'filament.pages.effective-settings';
public ?int $bookingId = null;
public static function canAccess(): bool
{
return (bool) auth()->user()?->hasRole(UserRole::Admin);
}
public function mount(): void
{
$this->bookingId = is_numeric(request()->query('vorgang')) ? (int) request()->query('vorgang') : null;
}
/**
* Every way a case of a property can come in, with the profile that would apply now.
*
* @return list<array{property: Property, columns: list<array{label: string, profile: ProcessProfile}>}>
*/
public function matrix(): array
{
$settings = app(ProcessSettings::class);
return Property::query()->orderBy('name')->get()->map(function (Property $property) use ($settings): array {
$columns = [['label' => 'Direkte Anfrage (Webseite, Telefon)', 'profile' => $settings->resolve($property, null, IntakeKind::Inquiry)]];
foreach (Channel::query()->where('property_id', $property->id)->orderBy('name')->get() as $channel) {
$columns[] = ['label' => $channel->name.' – Anfrage', 'profile' => $settings->resolve($property, $channel, IntakeKind::Inquiry)];
$columns[] = ['label' => $channel->name.' – feste Buchung', 'profile' => $settings->resolve($property, $channel, IntakeKind::Booking)];
}
$columns[] = ['label' => 'Eigene Nutzung / Sperre (A6)', 'profile' => $settings->resolve($property, null, IntakeKind::Internal)];
return ['property' => $property, 'columns' => $columns];
})->all();
}
/**
* @return list<ProcessSetting>
*/
public function settings(): array
{
return ProcessSetting::cases();
}
public function describe(ProcessSetting $setting, ProcessProfile $profile): string
{
$value = $profile->value($setting);
if ($setting === ProcessSetting::ContractTemplate) {
return $value === null ? 'Texte der Webseite' : (ContractTemplate::query()->find($value)?->label() ?? 'Vorlage Nr. '.$value);
}
return $setting->describe($value);
}
/**
* Where a setting is changed in the application.
*/
public static function where(ProcessSetting $setting): string
{
return $setting === ProcessSetting::ContractTemplate
? 'Wohnung › Abweichende Abwicklung (Experte) bzw. Portal › Anfragen / Feste Buchungen'
: 'System › So arbeite ich; Abweichung: Wohnung (Experte), Portal je Anfrage/feste Buchung'.($setting->channelIntakes() === [] ? ' (kein Portal)' : '');
}
/**
* Recent cases to check.
*
* @return array<int, string>
*/
public function cases(): array
{
return Booking::query()->with('guest')->latest('id')->limit(60)->get()
->mapWithKeys(fn (Booking $booking): array => [$booking->id => $booking->reference.' · '.$booking->guestName().' · '.$booking->caseType()->value])->all();
}
public function booking(): ?Booking
{
return $this->bookingId ? Booking::query()->find($this->bookingId) : null;
}
}
@@ -4,8 +4,10 @@
use App\Filament\Concerns\ListsCurrentProperty;
use App\Filament\Resources\BlockedPeriods\BlockedPeriodResource;
use Filament\Actions\CreateAction;
use App\Filament\Resources\Bookings\BookingResource;
use Filament\Actions\Action;
use Filament\Resources\Pages\ManageRecords;
use Filament\Support\Icons\Heroicon;
class ManageBlockedPeriods extends ManageRecords
{
@@ -16,7 +18,8 @@ class ManageBlockedPeriods extends ManageRecords
protected function getHeaderActions(): array
{
return [
CreateAction::make()->label('Zeitraum sperren')->mutateDataUsing(fn (array $data): array => [...$data, 'source' => 'manual']),
// New blocks are cases (A6) with their own page, history and portal tasks; this list keeps the old ones.
Action::make('createCase')->label('Zeitraum sperren')->icon(Heroicon::OutlinedPlus)->url(BookingResource::getUrl('create', ['kind' => 'block'])),
];
}
}
@@ -3,11 +3,12 @@
namespace App\Filament\Resources\Bookings\Pages;
use App\Actions\ConfirmBooking;
use App\Actions\CreateInternalCase;
use App\Actions\CreateReservation;
use App\Actions\SendBookingDocuments;
use App\Actions\TakeOverExternalBooking;
use App\Enums\InternalKind;
use App\Exceptions\ReservationException;
use App\Filament\Resources\BlockedPeriods\BlockedPeriodResource;
use App\Filament\Resources\Bookings\BookingResource;
use App\Filament\Resources\Bookings\Schemas\BookingForm;
use App\Models\Booking;
@@ -37,9 +38,8 @@ class CreateBooking extends CreateRecord
*/
protected function handleRecordCreation(array $data): Model
{
if (($data['kind'] ?? null) === BookingForm::OWN_USE) {
$this->redirect(BlockedPeriodResource::getUrl());
$this->halt();
if (in_array($data['kind'] ?? null, [BookingForm::OWN_USE, BookingForm::BLOCK], true)) {
return $this->createInternal($data);
}
try {
@@ -88,6 +88,58 @@ protected function handleRecordCreation(array $data): Model
return $booking;
}
/**
* Pre-filled from the calendar or the block list (?kind=block&von=…&bis=…&wohnung=…).
*/
protected function afterFill(): void
{
$kind = request()->query('kind');
if (in_array($kind, [BookingForm::INQUIRY, BookingForm::EXTERNAL, BookingForm::OWN_USE, BookingForm::BLOCK], true)) {
$this->data['kind'] = $kind;
}
foreach (['von' => 'arrival', 'bis' => 'departure'] as $parameter => $field) {
$value = request()->query($parameter);
if (is_string($value) && preg_match('/^\d{4}-\d{2}-\d{2}$/', $value) === 1) {
$this->data[$field] = $value;
}
}
if (is_numeric(request()->query('wohnung')) && Property::query()->whereKey((int) request()->query('wohnung'))->exists()) {
$this->data['property_id'] = (int) request()->query('wohnung');
}
}
/**
* Own use, a private stay or a block as a case (A6).
*
* @param array<string, mixed> $data
*/
private function createInternal(array $data): Model
{
$kind = $data['kind'] === BookingForm::BLOCK ? InternalKind::Block : InternalKind::from((string) ($data['internal_kind'] ?? InternalKind::OwnUse->value));
$extras = [];
foreach ((array) ($data['items'] ?? []) as $item) {
if (filled($item['extra_id'] ?? null)) {
$extras[(int) $item['extra_id']] = ((int) ($extras[(int) $item['extra_id']] ?? 0)) + max(1, (int) ($item['quantity'] ?? 1));
}
}
try {
return app(CreateInternalCase::class)->handle(Property::query()->findOrFail($data['property_id']), $kind, CarbonImmutable::parse($data['arrival']), CarbonImmutable::parse($data['departure']), [
'occasion' => $data['occasion'] ?? null,
'guest' => ['first_name' => $data['stay_first_name'] ?? null, 'last_name' => $data['stay_last_name'] ?? null, 'email' => $data['stay_email'] ?? null, 'phone' => $data['stay_phone'] ?? null],
'guests' => $data['guests'] ?? null,
'extras' => $extras,
'rent' => (int) ($data['rent'] ?? 0),
'tourist_tax_persons' => filled($data['tourist_tax_persons'] ?? null) ? (int) $data['tourist_tax_persons'] : null,
'tourist_tax_note' => $data['tourist_tax_note'] ?? null,
'notes' => $data['internal_notes'] ?? null,
]);
} catch (QuoteException|ReservationException $exception) {
Notification::make()->title('Nicht möglich')->body($exception->getMessage())->danger()->send();
$this->halt();
}
}
protected function getRedirectUrl(): string
{
/** @var Booking $record */
@@ -3,18 +3,27 @@
namespace App\Filament\Resources\Bookings\Pages;
use App\Actions\CancelBooking;
use App\Actions\ChangeBooking;
use App\Actions\ConfirmBooking;
use App\Actions\DeclineBooking;
use App\Actions\EndInternalCase;
use App\Actions\ProvideGuestContact;
use App\Actions\RecordPortalAmounts;
use App\Actions\SendBookingDocuments;
use App\Actions\SendOffer;
use App\Actions\SetBookingStatus;
use App\Documents\OfferTerms;
use App\Documents\RentalContract;
use App\Enums\AdminMode;
use App\Enums\AmountKind;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\ChangeBasis;
use App\Enums\ChangeStatus;
use App\Enums\DocumentKind;
use App\Enums\IntakeKind;
use App\Enums\InternalKind;
use App\Enums\ProcessingMode;
use App\Enums\Responsibility;
use App\Exceptions\ReservationException;
@@ -23,18 +32,22 @@
use App\Filament\Forms\DocumentCompositionFields;
use App\Filament\Resources\Bookings\BookingResource;
use App\Models\Booking;
use App\Models\BookingChange;
use App\Models\BookingTask;
use App\Models\ContractAnnex;
use App\Models\ContractTemplate;
use App\Models\Extra;
use App\Models\User;
use App\Pricing\PortalPrice;
use App\Pricing\PrivateStayPrice;
use App\Pricing\QuoteException;
use App\Process\CaseActivities;
use App\Process\CaseAutomation;
use App\Process\CaseLog;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Filament\Actions\Action;
use Filament\Actions\ActionGroup;
use Filament\Forms\Components\Checkbox;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\DateTimePicker;
use Filament\Forms\Components\Hidden;
@@ -50,6 +63,7 @@
use Filament\Schemas\Components\Section;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Filament\Schemas\Components\View;
use Filament\Support\Icons\Heroicon;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Support\Arr;
@@ -91,6 +105,9 @@ protected function getHeaderActions(): array
$this->sendDocumentsAction(),
$this->resendConfirmationAction(),
$this->portalPriceAction(),
$this->changeAction(),
$this->confirmPortalCancellationAction(),
$this->withdrawChangeAction(),
$this->extendHoldAction(),
$this->servicesAction(),
$this->offerPdfAction(),
@@ -191,7 +208,8 @@ private function sendDocumentsAction(): Action
return Action::make('sendDocuments')
->label(fn (): string => SendBookingDocuments::kindFor($this->record) === DocumentKind::ExternalRecord ? 'Buchungsunterlagen prüfen und senden' : 'Bestätigung prüfen und senden')
->icon(Heroicon::OutlinedPaperAirplane)
->visible(fn (): bool => $this->record->isBinding() && $this->record->confirmation_sent_at === null && $this->record->confirmation_failed_at === null && $this->record->process()->documents() === Responsibility::Landlord)
->visible(fn (): bool => $this->record->isBinding() && $this->record->confirmation_sent_at === null && $this->record->confirmation_failed_at === null
&& ($this->record->process()->documents() === Responsibility::Landlord || ($this->record->isInternal() && $this->record->internal_kind !== InternalKind::Block && filled($this->record->guest?->email))))
->modalHeading(fn (): string => SendBookingDocuments::kindFor($this->record)->getLabel())
->modalDescription('So gehen die Unterlagen an den Gast. „Anpassen“ nur bei Bedarf.')
->modalSubmitActionLabel('Senden')
@@ -239,7 +257,7 @@ private function provideContactAction(): Action
return Action::make('provideContact')
->label(fn (): string => $this->record->guest === null ? 'Gast eintragen' : 'Kontaktdaten eintragen')
->icon(Heroicon::OutlinedUserPlus)
->visible(fn (): bool => ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true))
->visible(fn (): bool => $this->record->internal_kind !== InternalKind::Block && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true))
->modalHeading('Kontaktdaten des Gastes')
->modalDescription('Aus Portalnachricht, E-Mail oder Telefonat. Nur eintragen, was bekannt ist.')
->modalWidth('3xl')
@@ -286,7 +304,7 @@ private function requestContactAction(): Action
return Action::make('requestContact')
->label('Gast um Kontaktdaten bitten')
->icon(Heroicon::OutlinedChatBubbleLeftEllipsis)
->visible(fn (): bool => blank($this->record->guest?->email) && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true))
->visible(fn (): bool => ! $this->record->isInternal() && blank($this->record->guest?->email) && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired], true))
->modalHeading('Gast um Kontaktdaten bitten')
->modalDescription('Den Text im Nachrichtenfenster des Portals einfügen (Sie senden ihn selbst). „Als angefragt vermerken“ hält fest, dass die Daten erfragt sind.')
->modalSubmitActionLabel('Als angefragt vermerken')
@@ -361,28 +379,204 @@ private function resendConfirmationAction(): Action
});
}
/**
* What the portal shows about the booking (package 8): the guest's total as the agreed price and – optional, folded
* away – its positions, commission, announced payouts, instalments and what the guest paid to the portal.
*/
private function portalPriceAction(): Action
{
return Action::make('portalPrice')
->label('Gesamtpreis laut Portal eintragen')
->label('Preis laut Portal eintragen')
->icon(Heroicon::OutlinedCurrencyEuro)
->visible(fn (): bool => $this->record->intake === IntakeKind::Booking && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined], true))
->modalDescription('Der Betrag, den der Gast beim Portal gebucht hat (Gesamtpreis). Er wird so übernommen und nicht in eigene Positionen zerlegt.')
->fillForm(fn (): array => ['portal_total' => $this->record->total, 'guests' => $this->record->guests])
->modalHeading(fn (): string => 'Beträge laut '.($this->record->processChannel()?->name ?? 'Portal'))
->modalDescription('Der Gesamtpreis, den der Gast beim Portal gebucht hat, wird so übernommen und nicht neu berechnet. Einzelheiten nur eintragen, wenn das Portal sie zeigt – nichts schätzen. Abweichende Angaben (z. B. zwei verschiedene Auszahlungsbeträge) einfach beide eintragen.')
->modalWidth('4xl')
->fillForm(fn (): array => ['portal_total' => $this->record->total, 'guests' => $this->record->guests, 'stated_on' => today()->toDateString(), 'amounts' => [], 'paid' => []])
->schema([
EuroInput::make('portal_total')->label('Gesamtpreis laut Portal')->required(),
TextInput::make('guests')->label('Personen (falls bekannt)')->integer()->minValue(1),
Section::make()->columns(3)->schema([
EuroInput::make('portal_total')->label('Gesamtpreis des Gastes laut Portal')->required(),
TextInput::make('guests')->label('Personen (falls bekannt)')->integer()->minValue(1),
DatePicker::make('stated_on')->label('Stand der Angaben')->required(),
]),
Section::make('Einzelheiten laut Portal (optional)')->collapsed()->schema([
Repeater::make('amounts')->label('Positionen und Angaben')->addActionLabel('Angabe hinzufügen')->columns(4)->defaultItems(0)->schema([
Select::make('kind')->label('Art')->options(AmountKind::class)->required()->columnSpan(2),
TextInput::make('label')->label('Bezeichnung laut Portal')->placeholder('z. B. Gebühren und Steuern')->maxLength(150),
EuroInput::make('amount')->label('Betrag')->minValue(null)->required(),
DatePicker::make('due_on')->label('fällig am (bei Raten)'),
TextInput::make('note')->label('Notiz')->maxLength(500)->columnSpan(3),
]),
Repeater::make('paid')->label('Vom Gast laut Portal bereits bezahlt')->addActionLabel('Zahlung laut Portal hinzufügen')->columns(2)->defaultItems(0)->schema([
EuroInput::make('amount')->label('Betrag')->required(),
DatePicker::make('paid_on')->label('bezahlt am')->required(),
]),
]),
])
->action(function (array $data, PortalPrice $price): void {
$guests = filled($data['guests'] ?? null) ? (int) $data['guests'] : $this->record->guests;
$this->record->update(['guests' => $guests, ...$price->columns($this->record->property, $this->record->arrival, $this->record->departure, $guests, (int) $data['portal_total'], $this->record->processChannel()?->name)]);
CaseLog::record($this->record, 'price', 'Gesamtpreis laut Portal eingetragen: '.Money::format((int) $data['portal_total']));
$blockers = app(CaseAutomation::class)->advance($this->record->fresh());
->action(function (array $data, RecordPortalAmounts $amounts): void {
if (filled($data['guests'] ?? null)) {
$this->record->update(['guests' => (int) $data['guests']]);
}
$amounts->handle(
$this->record->fresh(),
(int) $data['portal_total'],
array_map(fn (array $row): array => [...$row, 'amount' => (int) $row['amount']], array_values((array) ($data['amounts'] ?? []))),
array_map(fn (array $row): array => ['amount' => (int) $row['amount'], 'paid_on' => (string) $row['paid_on']], array_values((array) ($data['paid'] ?? []))),
$this->record->processChannel()?->name ?? 'Portal',
CarbonImmutable::parse($data['stated_on']),
auth()->user()?->name,
);
$this->record->refresh();
Notification::make()->title('Preis gespeichert')->body($blockers === [] ? null : implode(' ', $blockers))->success()->send();
$blockers = app(CaseAutomation::class)->documentBlockers($this->record);
Notification::make()->title('Beträge gespeichert')->body($blockers === [] ? null : implode(' ', $blockers))->success()->send();
});
}
/**
* "Ändern" of a booking or internal case (package 5): dates, guests, services and price with the consequences shown
* before saving; either recorded as already agreed with the guest, or proposed to the guest for consent.
*/
private function changeAction(): Action
{
$own = fn (): bool => ! $this->record->isInternal() && ! $this->record->caseType()->isExternallyBinding();
return Action::make('change')
->label(fn (): string => $this->record->isInternal() ? 'Ändern oder verlängern …' : 'Buchung ändern …')
->icon(Heroicon::OutlinedPencil)
->visible(fn (): bool => in_array($this->record->status, BookingStatus::occupying(), true) && $this->record->portal_cancellation_requested_at === null)
->modalHeading(fn (): string => $this->record->isInternal() ? 'Zeitraum oder Angaben ändern' : 'Buchung ändern')
->modalDescription('Tragen Sie ein, was sich ändert. Unten sehen Sie vor dem Speichern, was daraus folgt.')
->modalSubmitActionLabel('Speichern')
->modalWidth('4xl')
->fillForm(fn (): array => [
'arrival' => $this->record->arrival->toDateString(),
'departure' => $this->record->departure->toDateString(),
'guests' => $this->record->guests,
'items' => collect((array) $this->record->extras)->map(fn ($quantity, $id): array => ['extra_id' => (int) $id, 'quantity' => (int) $quantity])->values()->all(),
'rent' => $this->record->isInternal() ? PrivateStayPrice::rentOf($this->record->quote) : null,
'tourist_tax_persons' => $this->record->tourist_tax_persons,
'way' => 'agreed',
'requested_by' => $this->record->caseType()->isExternallyBinding() ? 'portal' : 'guest',
'basis' => $this->record->caseType()->isExternallyBinding() ? ChangeBasis::Portal->value : ChangeBasis::Phone->value,
'agreed_at' => now()->format('Y-m-d H:i'),
'effective_on' => today()->toDateString(),
'send_confirmation' => false,
])
->schema(fn (): array => [
Section::make()->columns(3)->schema([
DatePicker::make('arrival')->label('Anreise / Beginn')->required()->live(onBlur: true),
DatePicker::make('departure')->label('Abreise / Ende')->after('arrival')->required()->live(onBlur: true),
TextInput::make('guests')->label('Personen')->integer()->minValue(1)->live(onBlur: true)->visible(fn (): bool => $this->record->internal_kind !== InternalKind::Block),
]),
Repeater::make('items')->label('Zusatzleistungen')->columns(2)->defaultItems(0)->addActionLabel('Leistung hinzufügen')->live()
->visible(fn (): bool => $this->record->internal_kind !== InternalKind::Block && ! $this->record->caseType()->isExternallyBinding())
->schema([
Select::make('extra_id')->label('Leistung')->options(fn (): array => Extra::query()->where('property_id', $this->record->property_id)->orderBy('name')->pluck('name', 'id')->all())->required(),
TextInput::make('quantity')->label('Menge')->integer()->minValue(1)->default(1)->required(),
]),
Section::make('Preis')->columns(2)->visible(fn (): bool => $this->record->internal_kind !== InternalKind::Block)->schema([
EuroInput::make('portal_total')->label('Neuer Gesamtpreis laut Portal')->helperText('Leer lassen, wenn das Portal den Preis nicht geändert hat.')->live(onBlur: true)
->visible(fn (): bool => $this->record->caseType()->isExternallyBinding()),
EuroInput::make('agreed_total')->label('Vereinbarter Gesamtpreis (optional)')->helperText('Leer lassen: Der Preis wird aus Ihren Preisen neu berechnet.')->live(onBlur: true)
->visible($own),
EuroInput::make('rent')->label('Vereinbarte Miete')->live(onBlur: true)->visible(fn (): bool => $this->record->isInternal()),
TextInput::make('tourist_tax_persons')->label('Kurabgabe: Personen')->integer()->minValue(0)->live(onBlur: true)->visible(fn (): bool => $this->record->isInternal()),
]),
View::make('filament.change-preview')->viewData(fn (Get $get): array => ['preview' => app(ChangeBooking::class)->preview($this->record, $this->changeData(self::formState($get, ['arrival', 'departure', 'guests', 'items', 'portal_total', 'agreed_total', 'rent', 'tourist_tax_persons'])))]),
Section::make('Grundlage')->columns(2)->visible(fn (): bool => ! $this->record->isInternal())->schema([
Radio::make('way')->label('Wie kommt die Änderung zustande?')->columnSpanFull()->live()->required()->options(fn (): array => array_filter([
'agreed' => 'Mit dem Gast bereits vereinbart – jetzt eintragen',
'propose' => $own() && filled($this->record->guest?->email) ? 'Dem Gast vorschlagen – wird erst mit seiner Zustimmung wirksam' : null,
])),
Select::make('requested_by')->label('Wer möchte die Änderung?')->options(BookingChange::REQUESTERS)->required(),
Select::make('basis')->label('Wie vereinbart?')->options(collect(ChangeBasis::cases())->reject(fn (ChangeBasis $basis): bool => in_array($basis, [ChangeBasis::GuestLink, ChangeBasis::NotNeeded], true))->mapWithKeys(fn (ChangeBasis $basis): array => [$basis->value => $basis->getLabel()])->all())
->visible(fn (Get $get): bool => $get('way') === 'agreed')->required(fn (Get $get): bool => $get('way') === 'agreed'),
DateTimePicker::make('agreed_at')->label('Vereinbart am')->seconds(false)->visible(fn (Get $get): bool => $get('way') === 'agreed'),
DatePicker::make('effective_on')->label('Wirksam ab'),
Toggle::make('send_confirmation')->label('Bestätigung der Änderung an den Gast senden')->visible(fn (Get $get): bool => $get('way') === 'agreed' && filled($this->record->guest?->email)),
]),
Textarea::make('reason')->label('Grund')->required()->rows(2),
])
->action(function (array $data, ChangeBooking $changes): void {
$meta = [
'requested_by' => $this->record->isInternal() ? 'landlord' : ($data['requested_by'] ?? 'landlord'),
'reason' => (string) $data['reason'],
'basis' => $this->record->isInternal() ? ChangeBasis::NotNeeded : ChangeBasis::from((string) ($data['basis'] ?? ChangeBasis::Phone->value)),
'agreed_at' => $data['agreed_at'] ?? null,
'effective_on' => $data['effective_on'] ?? null,
'send_confirmation' => (bool) ($data['send_confirmation'] ?? false),
];
$this->runWorkflow(fn () => ($data['way'] ?? 'agreed') === 'propose' && ! $this->record->isInternal()
? $changes->propose($this->record, $this->changeData($data), $meta, auth()->user()?->name)
: $changes->apply($this->record, $this->changeData($data), $meta, auth()->user()?->name), ($data['way'] ?? 'agreed') === 'propose' ? 'Vorschlag an den Gast gesendet' : 'Änderung gespeichert');
});
}
/**
* A booking binding on a portal is only cancelled here once the cancellation is effective on the portal.
*/
private function confirmPortalCancellationAction(): Action
{
$reported = fn (): bool => BookingTask::query()->where('booking_id', $this->record->id)->where('kind', BookingTaskKind::PortalCancellationReported)->where('status', BookingTaskStatus::Open)->exists();
return Action::make('confirmPortalCancellation')
->label(fn (): string => $reported() ? 'Stornierung übernehmen …' : 'Stornierung bestätigen …')
->icon(Heroicon::OutlinedCheckBadge)
->color('danger')
->visible(fn (): bool => in_array($this->record->status, BookingStatus::occupying(), true) && $this->record->caseType()->isExternallyBinding()
&& ($this->record->portal_cancellation_requested_at !== null || $reported()))
->modalHeading('Ist die Stornierung im Portal wirksam?')
->modalDescription(fn (): string => 'Erst jetzt wird der Vorgang storniert und der Zeitraum frei. Bitte vorher im Portal „'.($this->record->processChannel()?->name ?? 'Portal').'“ nachsehen. Bleibt die Buchung im Portal bestehen, die Aufgabe einfach im Reiter „Aufgaben“ erledigen.')
->modalSubmitActionLabel('Storniert – übernehmen')
->fillForm(fn (): array => ['initiated_by' => $reported() ? 'portal' : 'landlord'])
->schema([
Radio::make('initiated_by')->label('Wer hat storniert?')->options(CancelBooking::INITIATORS)->required(),
Textarea::make('reason')->label('Grund / Hinweis')->rows(2),
Checkbox::make('effective')->label('Die Stornierung ist im Portal wirksam (geprüft).')->accepted(),
])
->action(fn (array $data, CancelBooking $cancel) => $this->runWorkflow(fn () => $cancel->confirmOnPortal($this->record, (string) auth()->user()?->name, $data['initiated_by'], $data['reason'] ?? null), 'Buchung storniert'));
}
private function withdrawChangeAction(): Action
{
return Action::make('withdrawChange')
->label('Änderungsvorschlag zurückziehen')
->icon(Heroicon::OutlinedArrowUturnLeft)
->visible(fn (): bool => $this->record->changes()->where('status', ChangeStatus::Proposed)->exists())
->requiresConfirmation()
->action(function (ChangeBooking $changes): void {
$changes->withdraw($this->record->changes()->where('status', ChangeStatus::Proposed)->firstOrFail(), auth()->user()?->name);
Notification::make()->title('Vorschlag zurückgezogen')->success()->send();
});
}
/**
* Form data of the change dialog as changes for {@see ChangeBooking}.
*
* @param array<string, mixed> $data
* @return array<string, mixed>
*/
private function changeData(array $data): array
{
$extras = [];
foreach ((array) ($data['items'] ?? []) as $item) {
if (filled($item['extra_id'] ?? null)) {
$extras[(int) $item['extra_id']] = ((int) ($extras[(int) $item['extra_id']] ?? 0)) + max(1, (int) ($item['quantity'] ?? 1));
}
}
return array_filter([
'arrival' => $data['arrival'] ?? null,
'departure' => $data['departure'] ?? null,
'guests' => filled($data['guests'] ?? null) ? (int) $data['guests'] : null,
'extras' => $this->record->internal_kind === InternalKind::Block || $this->record->caseType()->isExternallyBinding() ? null : $extras,
'portal_total' => filled($data['portal_total'] ?? null) ? (int) $data['portal_total'] : null,
'agreed_total' => filled($data['agreed_total'] ?? null) ? (int) $data['agreed_total'] : null,
'rent' => $this->record->isInternal() && filled($data['rent'] ?? null) ? (int) $data['rent'] : null,
'tourist_tax_persons' => $this->record->isInternal() && filled($data['tourist_tax_persons'] ?? null) ? (int) $data['tourist_tax_persons'] : null,
], fn ($value): bool => $value !== null);
}
private function extendHoldAction(): Action
{
return Action::make('extendHold')
@@ -402,7 +596,7 @@ private function servicesAction(): Action
return Action::make('services')
->label('Zusatzleistungen erfassen')
->icon(Heroicon::OutlinedPlusCircle)
->visible(fn (): bool => ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true))
->visible(fn (): bool => ! $this->record->isInternal() && ! in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true))
->modalDescription('Gebuchte Zusatzleistungen (z. B. aus einer Portalbuchung). Sie bestimmen, welche Vertragsanlagen angehängt werden. Der Preis ändert sich dadurch nicht.')
->fillForm(fn (): array => ['items' => collect((array) $this->record->extras)->map(fn ($quantity, $id): array => ['extra_id' => (int) $id, 'quantity' => (int) $quantity])->values()->all()])
->schema([
@@ -525,7 +719,8 @@ private function setStatusAction(): Action
*/
private function automationAction(): ?Action
{
if (in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true)) {
// Own use, private stays and blocks have nothing that could run by itself.
if ($this->record->isInternal() || in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true)) {
return null;
}
@@ -554,11 +749,28 @@ private function automationAction(): ?Action
*/
private function endAction(): ?Action
{
if (in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true)) {
if (in_array($this->record->status, [BookingStatus::Cancelled, BookingStatus::Declined, BookingStatus::Expired, BookingStatus::Completed], true)
|| $this->record->portal_cancellation_requested_at !== null) {
return null;
}
if ($this->record->isInternal()) {
$label = EndInternalCase::label($this->record);
return Action::make('end')
->label($this->record->internal_kind === InternalKind::Block ? 'Sperre aufheben …' : 'Aufenthalt absagen …')
->icon(Heroicon::OutlinedStopCircle)
->color('danger')
->outlined()
->modalHeading($label)
->modalDescription('Keine Stornierung: Es entstehen keine Kosten und keine Mails. Der Zeitraum wird frei, die Portale werden wieder freigegeben.')
->modalSubmitActionLabel($this->record->internal_kind === InternalKind::Block ? 'Aufheben' : 'Absagen')
->schema([Textarea::make('reason')->label('Grund')->required()->rows(2)])
->action(fn (array $data, EndInternalCase $end) => $this->runWorkflow(fn () => $end->handle($this->record, trim((string) $data['reason']), auth()->user()?->name), $label));
}
$binding = $this->record->isBinding();
$external = $binding && $this->record->caseType()->isExternallyBinding();
$hasEmail = filled($this->record->guest?->email);
return Action::make('end')
@@ -567,22 +779,25 @@ private function endAction(): ?Action
->color('danger')
->outlined()
->modalHeading($binding ? 'Gebuchten Vorgang stornieren' : 'Vorgang ohne Buchung beenden')
->modalDescription($binding
? 'Die Buchung ist verbindlich. Sie wird storniert, der Zeitraum frei. Stornokosten nach der vereinbarten Regel bleiben als Aufgabe offen.'.($this->record->caseType()->isExternallyBinding() ? ' Gebucht wurde beim Portal – dafür entsteht zusätzlich die Aufgabe, die Stornierung dort zu veranlassen bzw. zu prüfen.' : '')
: 'Es ist noch keine verbindliche Buchung zustande gekommen. Der reservierte Zeitraum wird wieder frei.')
->modalSubmitActionLabel($binding ? 'Stornieren' : 'Beenden')
->modalDescription(match (true) {
$external => 'Gebucht wurde beim Portal „'.($this->record->processChannel()?->name ?? 'Portal').'“ – storniert wird dort. Hier entsteht die Aufgabe, die Stornierung im Portal zu veranlassen; der Vorgang bleibt gebucht, bis Sie bestätigen, dass sie dort wirksam ist. Nichts wird still gelöscht.',
$binding => 'Die Buchung ist verbindlich. Sie wird storniert, der Zeitraum frei. Stornokosten nach der vereinbarten Regel und eine mögliche Erstattung bleiben als Aufgaben offen.',
default => 'Es ist noch keine verbindliche Buchung zustande gekommen. Der reservierte Zeitraum wird wieder frei.',
})
->modalSubmitActionLabel($external ? 'Stornierung veranlassen' : ($binding ? 'Stornieren' : 'Beenden'))
->schema(array_values(array_filter([
$binding ? Radio::make('initiated_by')->label('Wer storniert?')->options(['guest' => 'Der Gast', 'landlord' => 'Wir (Vermieter)'])->required() : null,
$binding ? Radio::make('initiated_by')->label('Wer storniert?')->options($external ? CancelBooking::INITIATORS : ['guest' => 'Der Gast', 'landlord' => 'Wir (Vermieter)'])->required() : null,
Textarea::make('reason')->label('Grund')->required()->rows(2),
Toggle::make('notify')->label('Den Gast per E-Mail informieren')->default($hasEmail)->disabled(! $hasEmail),
$binding ? Toggle::make('costs_task')->label('Aufgabe „Stornokosten prüfen“ anlegen')->default(true) : null,
$external ? null : Toggle::make('notify')->label('Den Gast per E-Mail informieren')->default($hasEmail)->disabled(! $hasEmail),
$binding && ! $external ? Toggle::make('costs_task')->label('Aufgabe „Stornokosten prüfen“ anlegen')->default(true) : null,
])))
->action(function (array $data, CancelBooking $cancel, DeclineBooking $decline) use ($binding, $hasEmail): void {
$notify = $hasEmail && (bool) ($data['notify'] ?? false);
->action(function (array $data, CancelBooking $cancel, DeclineBooking $decline) use ($binding, $external, $hasEmail): void {
$notify = ! $external && $hasEmail && (bool) ($data['notify'] ?? false);
$reason = trim((string) $data['reason']);
try {
$informed = CaseLog::context(fn () => $binding
? $cancel->handle($this->record, $notify, (bool) ($data['costs_task'] ?? true), auth()->user()->name, $data['initiated_by'])
: $decline->handle($this->record, $notify), reason: trim((string) $data['reason']));
? $cancel->handle($this->record, $notify, (bool) ($data['costs_task'] ?? true), auth()->user()->name, $data['initiated_by'], $reason)
: $decline->handle($this->record, $notify), reason: $reason);
} catch (ReservationException $exception) {
Notification::make()->title('Nicht möglich')->body($exception->getMessage())->danger()->send();
@@ -590,7 +805,11 @@ private function endAction(): ?Action
}
$this->record->refresh();
$notification = Notification::make()->title($binding ? 'Buchung storniert' : 'Vorgang beendet');
$notification = Notification::make()->title(match (true) {
$external => 'Stornierung im Portal veranlassen',
$binding => 'Buchung storniert',
default => 'Vorgang beendet',
});
($informed === false ? $notification->warning()->body('Die Mail an den Gast konnte nicht gesendet werden – bitte selbst informieren.') : $notification->success())->send();
});
}
@@ -3,15 +3,19 @@
namespace App\Filament\Resources\Bookings\RelationManagers;
use App\Actions\RecordPayment;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Enums\Responsibility;
use App\Filament\Forms\Components\EuroInput;
use App\Models\Booking;
use App\Models\Payment;
use App\Pricing\CaseMoney;
use App\Support\Money;
use Carbon\CarbonImmutable;
use Filament\Actions\Action;
use Filament\Actions\DeleteAction;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
@@ -38,11 +42,13 @@ public function table(Table $table): Table
{
return $table
->recordTitleAttribute('amount')
->description(fn (): string => 'Bezahlt: '.Money::format($this->ownerRecord->paidAmount()).' · offen: '.Money::format($this->ownerRecord->openAmount()))
->description(fn (): string => 'Vom Gast bezahlt: '.Money::format($this->ownerRecord->paidAmount()).' (davon an uns '.Money::format($this->ownerRecord->paidToUs()).', laut Portal ans Portal '.Money::format($this->ownerRecord->paidViaPortal()).') · Auszahlungen vom Portal: '.Money::format($this->ownerRecord->payoutsReceived()).' · offen bei uns: '.Money::format(CaseMoney::of($this->ownerRecord)->openForUs()))
->columns([
TextColumn::make('paid_on')->label('Eingang')->date('d.m.Y'),
TextColumn::make('amount')->label('Betrag')->money('EUR', divideBy: 100, locale: 'de'),
TextColumn::make('method')->label('Art'),
TextColumn::make('kind')->label('Was')->badge()->state(fn (Payment $record): PaymentKind => $record->kind ?? PaymentKind::Guest),
TextColumn::make('method')->label('Zahlweg'),
TextColumn::make('source')->label('Quelle')->placeholder('–')->toggleable(isToggledHiddenByDefault: true),
TextColumn::make('note')->label('Notiz')->placeholder('–'),
TextColumn::make('recorded_by')->label('Erfasst von')->placeholder('–'),
])
@@ -54,9 +60,11 @@ public function table(Table $table): Table
'amount' => number_format(($this->ownerRecord->openDeposit() ?: $this->ownerRecord->openAmount()) / 100, 2, '.', ''),
'paid_on' => today(),
'method' => PaymentMethod::Transfer,
'kind' => $this->ownerRecord->process()->payments() === Responsibility::Portal ? PaymentKind::PortalPayout->value : PaymentKind::Guest->value,
])
->schema([
EuroInput::make('amount')->label('Betrag')->helperText('Erstattungen mit Minus erfassen.')->minValue(null)->required(),
Radio::make('kind')->label('Was ist passiert?')->options(PaymentKind::class)->required(),
EuroInput::make('amount')->label('Betrag')->helperText('Immer den Betrag ohne Vorzeichen; eine Erstattung wird automatisch abgezogen.')->required(),
DatePicker::make('paid_on')->label('Zahlungseingang')->required(),
Select::make('method')->label('Art')->options(PaymentMethod::class)->required(),
TextInput::make('note')->label('Notiz')->maxLength(255),
@@ -69,6 +77,8 @@ public function table(Table $table): Table
$data['method'] instanceof PaymentMethod ? $data['method'] : PaymentMethod::from($data['method']),
$data['note'] ?: null,
auth()->user()?->name,
$data['kind'] instanceof PaymentKind ? $data['kind'] : PaymentKind::from($data['kind']),
in_array($data['kind'] instanceof PaymentKind ? $data['kind']->value : $data['kind'], [PaymentKind::GuestViaPortal->value, PaymentKind::PortalPayout->value], true) ? ($this->ownerRecord->processChannel()?->name ?? 'Portal') : null,
);
Notification::make()->title('Zahlung erfasst – Status: '.$this->ownerRecord->fresh()->status->getLabel())->success()->send();
@@ -2,22 +2,23 @@
namespace App\Filament\Resources\Bookings\Schemas;
use App\Enums\InternalKind;
use App\Filament\Forms\Components\EuroInput;
use App\Filament\Resources\BlockedPeriods\BlockedPeriodResource;
use App\Models\Channel;
use App\Models\Extra;
use App\Models\Property;
use App\Support\CurrentProperty;
use App\Support\Money;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Repeater;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Toggle;
use Filament\Schemas\Components\Section;
use Filament\Schemas\Components\Text;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Schema;
use Illuminate\Support\HtmlString;
/**
* "Neu": one entry for everything that arrives outside the website. The first question is what it is – a request,
@@ -32,10 +33,14 @@ class BookingForm
public const OWN_USE = 'own_use';
public const BLOCK = 'block';
public static function configure(Schema $schema): Schema
{
$is = fn (string $kind): \Closure => fn (Get $get): bool => $get('kind') === $kind;
$isCase = fn (Get $get): bool => in_array($get('kind'), [self::INQUIRY, self::EXTERNAL], true);
$isInternal = fn (Get $get): bool => in_array($get('kind'), [self::OWN_USE, self::BLOCK], true);
$hasGuests = fn (Get $get): bool => $get('kind') === self::OWN_USE && $get('internal_kind') === InternalKind::PrivateStay->value;
return $schema
->components([
@@ -46,17 +51,25 @@ public static function configure(Schema $schema): Schema
->options([
self::INQUIRY => 'Eine Anfrage – per Telefon, E-Mail oder Nachricht über ein Portal',
self::EXTERNAL => 'Eine Buchung, die bei einem Portal schon fest gebucht ist',
self::OWN_USE => 'Eigene Nutzung oder eine Sperre (z. B. Wartung)',
self::OWN_USE => 'Eigene Nutzung oder Besuch von Familie und Freunden',
self::BLOCK => 'Eine Sperre ohne Gäste (z. B. Wartung, Renovierung)',
])
->default(self::INQUIRY)
->required()
->live(),
Text::make(new HtmlString('Eigene Nutzung und Sperren tragen Sie bis auf Weiteres unter <a class="underline" href="'.e(BlockedPeriodResource::getUrl()).'">Sperrzeiten</a> ein.'))
->visible($is(self::OWN_USE)),
Radio::make('internal_kind')
->label('Wer wohnt in der Wohnung?')
->options([InternalKind::OwnUse->value => 'Wir selbst (eigene Nutzung)', InternalKind::PrivateStay->value => 'Familie oder Freunde (private Überlassung, ohne Mietvertrag)'])
->default(InternalKind::OwnUse->value)
->visible($is(self::OWN_USE))
->live(),
TextInput::make('occasion')->label(fn (Get $get): string => $get('kind') === self::BLOCK ? 'Grund der Sperre' : 'Anlass')
->placeholder(fn (Get $get): string => $get('kind') === self::BLOCK ? 'z. B. Malerarbeiten im Bad' : 'z. B. Besuch von Tochter Anna')
->maxLength(255)->required($is(self::BLOCK))->visible($isInternal),
]),
Section::make('Zeitraum')
->columns(2)
->visible($isCase)
->visible(fn (Get $get): bool => $isCase($get) || $isInternal($get))
->schema([
Select::make('property_id')
->label('Wohnung')
@@ -69,9 +82,36 @@ public static function configure(Schema $schema): Schema
->integer()
->minValue(1)
->helperText(fn (Get $get): ?string => $get('kind') === self::EXTERNAL ? 'Leer lassen, wenn nicht bekannt.' : null)
->visible(fn (Get $get): bool => $get('kind') !== self::BLOCK)
->live(onBlur: true)
->required($is(self::INQUIRY)),
DatePicker::make('arrival')->label('Anreise')->required(),
DatePicker::make('departure')->label('Abreise')->after('arrival')->required(),
DatePicker::make('arrival')->label(fn (Get $get): string => $isInternal($get) ? 'Beginn' : 'Anreise')->required(),
DatePicker::make('departure')->label(fn (Get $get): string => $isInternal($get) ? 'Ende (erster freier Tag)' : 'Abreise')->after('arrival')->required(),
]),
Section::make('Gäste')
->description('Nur eintragen, was Sie brauchen – z. B. für eine Aufenthaltsbestätigung.')
->columns(2)
->visible($hasGuests)
->schema([
TextInput::make('stay_first_name')->label('Vorname')->maxLength(255),
TextInput::make('stay_last_name')->label('Nachname')->maxLength(255),
TextInput::make('stay_email')->label('E-Mail (für eine Bestätigung)')->email()->maxLength(255),
TextInput::make('stay_phone')->label('Telefon')->tel()->maxLength(50),
]),
Section::make('Leistungen und Kosten (optional)')
->description('Miete ist bei Familie meist 0 €. Zahlungen lassen sich später erfassen; es gibt keine Zahlungserinnerungen.')
->columns(2)
->visible($is(self::OWN_USE))
->collapsed(fn (Get $get): bool => $get('internal_kind') !== InternalKind::PrivateStay->value)
->schema([
EuroInput::make('rent')->label('Vereinbarte Miete')->default(0),
TextInput::make('tourist_tax_persons')->label('Kurabgabe: Personen')->integer()->minValue(0)
->helperText(fn (Get $get): string => ($rate = Property::query()->find($get('property_id'))?->tourist_tax_rate) ? 'Satz je Person und Nacht: '.Money::format((int) $rate).' (Wohnung › Kurabgabe)' : 'Kein Satz hinterlegt (Wohnung › Kurabgabe) – es wird nichts berechnet.'),
TextInput::make('tourist_tax_note')->label('Befreiungen / Hinweis zur Kurabgabe')->maxLength(255)->columnSpanFull(),
Repeater::make('items')->label('Zusatzleistungen')->columns(2)->defaultItems(0)->addActionLabel('Leistung hinzufügen')->columnSpanFull()->schema([
Select::make('extra_id')->label('Leistung')->options(fn (Get $get): array => Extra::query()->where('property_id', $get('../../property_id'))->orderBy('name')->pluck('name', 'id')->all())->required(),
TextInput::make('quantity')->label('Menge')->integer()->minValue(1)->default(1)->required(),
]),
]),
Section::make('Portal')
->columns(2)
@@ -113,7 +153,7 @@ public static function configure(Schema $schema): Schema
TextInput::make('promo_code')->label('Aktionscode')->maxLength(50),
]),
Section::make('Notiz')
->visible($isCase)
->visible(fn (Get $get): bool => $isCase($get) || $isInternal($get))
->collapsed()
->schema([
Textarea::make('internal_notes')->hiddenLabel()->placeholder('Interne Notiz (nur für Sie sichtbar)'),
@@ -9,8 +9,11 @@
use App\Enums\ProcessingMode;
use App\Enums\ProcessSetting;
use App\Enums\Responsibility;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\IntakeObservation;
use App\Models\User;
use App\Pricing\CaseMoney;
use App\Process\CaseActivities;
use App\Process\CaseAutomation;
use App\Process\ProcessProfile;
@@ -64,14 +67,10 @@ public static function configure(Schema $schema): Schema
TextEntry::make('label'),
TextEntry::make('amount')->formatStateUsing(fn (int $state): string => Money::format($state))->alignEnd(),
]),
Grid::make(4)->visible(fn (Booking $record): bool => $record->total !== null)->schema([
TextEntry::make('total')->label('Gesamtpreis')->money('EUR', divideBy: 100, locale: 'de')->weight('bold'),
TextEntry::make('paid')->label('Bezahlt')->state(fn (Booking $record): string => Money::format($record->paidAmount())),
TextEntry::make('open')->label('Offen')
->state(fn (Booking $record): string => $record->process()->payments() === Responsibility::Portal ? 'über das Portal' : Money::format($record->openAmount()))
->color(fn (Booking $record): string => $record->process()->payments() === Responsibility::Landlord && $record->openAmount() > 0 ? 'danger' : 'success'),
TextEntry::make('balance_due_on')->label('Rest fällig am')->date('d.m.Y')->placeholder('–'),
]),
TextEntry::make('money')->hiddenLabel()->html()
->state(fn (Booking $record): HtmlString => new HtmlString(view('filament.case-money', ['money' => CaseMoney::of($record), 'booking' => $record])->render())),
TextEntry::make('balance_due_on')->label('Restzahlung fällig am')->date('d.m.Y')
->visible(fn (Booking $record): bool => $record->wantsPaymentTasks() && $record->balance_due_on !== null),
]),
Section::make('Verlauf')
->collapsible()
@@ -105,7 +104,7 @@ public static function configure(Schema $schema): Schema
->schema([
TextEntry::make('documents')->hiddenLabel()->html()->state(fn (Booking $record): HtmlString => self::documents($record)),
TextEntry::make('document_kind')->label('Vorgesehen')->state(fn (Booking $record): string => DocumentKind::forCase($record)?->getLabel() ?? 'Unterlagen schickt das Portal'),
TextEntry::make('template')->label('Vorlage')->state(fn (Booking $record): string => isset($record->offer_terms['template']) && ($record->contract_path !== null || $record->offer_path !== null)
TextEntry::make('template')->label('Vorlage')->visible(fn (Booking $record): bool => ! $record->isInternal())->state(fn (Booking $record): string => isset($record->offer_terms['template']) && ($record->contract_path !== null || $record->offer_path !== null)
? $record->offer_terms['template']['name'].' (Version '.$record->offer_terms['template']['version'].', festgeschrieben)'
: (OfferTerms::templateFor($record)?->label() ?? 'Texte der Webseite').' (vorgesehen)'),
]),
@@ -123,6 +122,7 @@ public static function configure(Schema $schema): Schema
TextEntry::make('status')->label('Status')->badge(),
TextEntry::make('case_type')->label('Vorgangsart')->state(fn (Booking $record): string => strtoupper($record->caseType()->value).' – '.$record->caseType()->getLabel()),
TextEntry::make('intake')->label('Eingangsart')->state(fn (Booking $record): string => $record->intake?->getLabel() ?? '–'),
TextEntry::make('sources')->label('Quellen und Kalenderdarstellungen')->state(fn (Booking $record): HtmlString => self::sources($record))->html()->columnSpanFull(),
TextEntry::make('profile')->label('Abwicklungsprofil (eingefroren)')->state(fn (Booking $record): HtmlString => self::profile($record))->html()->columnSpanFull(),
TextEntry::make('hold_expires_at')->label('Reserviert bis')->dateTime('d.m.Y, H:i')->placeholder('–'),
TextEntry::make('offer_hash')->label('Angebot (Prüfsumme)')->state(fn (Booking $record): ?string => $record->offer_version > 0 ? 'Version '.$record->offer_version.' · '.substr((string) $record->offer_hash, 0, 16) : null)->placeholder('–'),
@@ -161,6 +161,22 @@ private static function nextStep(Booking $booking): HtmlString
.'<div style="margin-top:.5rem;color:#6b7280;font-size:.9rem">'.$mode.'</div>');
}
/**
* Every portal entry (calendar or e-mail) that belongs to the case, and what the intake recorded about it.
*/
private static function sources(Booking $booking): HtmlString
{
$lines = BlockedPeriod::query()->withTrashed()->with('channel')->where('linked_booking_id', $booking->id)->orderBy('id')->get()
->map(fn (BlockedPeriod $entry): string => e(($entry->source === 'email' ? 'E-Mail' : 'Kalender').' von '.($entry->channel?->name ?? '–').': '.$entry->starts_on->format('d.m.').'–'.$entry->ends_on->format('d.m.Y')
.($entry->trashed() ? ' · nicht mehr im Kalender' : '').($entry->starts_on->equalTo($booking->arrival) && $entry->ends_on->equalTo($booking->departure) ? '' : ' · abweichende Termine').' · Kennung '.$entry->external_uid));
$observations = IntakeObservation::query()->with('channel')->where('booking_id', $booking->id)->orderBy('occurred_at')->get()
->map(fn (IntakeObservation $observation): string => e($observation->occurred_at->format('d.m.Y H:i').' · '.$observation->sourceLabel().' '.$observation->channel?->name.' · '.$observation->outcome->getLabel().($observation->applied ? '' : ' (nur protokolliert)')));
$html = $lines->isEmpty() ? 'Keine Portaleinträge zugeordnet.' : $lines->implode('<br>');
return new HtmlString($observations->isEmpty() ? $html : $html.'<br><span style="color:#6b7280">Eingang: '.$observations->implode('<br>').'</span>');
}
/**
* The documents made for the case, as recorded when they were created (kind, template, date).
*/
@@ -2,9 +2,13 @@
namespace App\Filament\Resources\ChannelTasks\Tables;
use App\Enums\ChannelTaskAction;
use App\Enums\ChannelTaskProof;
use App\Enums\ChannelTaskStatus;
use App\Models\ChannelTask;
use Filament\Actions\Action;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Textarea;
use Filament\Support\Icons\Heroicon;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;
@@ -24,6 +28,8 @@ public static function configure(Table $table): Table
TextColumn::make('reason')->label('Anlass')->wrap(),
TextColumn::make('status')->label('Status')->badge()
->description(fn (ChannelTask $record): ?string => $record->completed_by ? "{$record->completed_by}, {$record->completed_at?->format('d.m. H:i')}" : null),
TextColumn::make('proof')->label('Nachweis')->state(fn (ChannelTask $record): string => $record->proofLabel())
->description(fn (ChannelTask $record): ?string => $record->proof_by ? "{$record->proof_by}, {$record->proof_at?->format('d.m. H:i')}" : null)->wrap(),
TextColumn::make('created_at')->label('Seit')->since(),
TextColumn::make('automation_error')->label('Automatisierung')->placeholder('–')->limit(40)->toggleable(isToggledHiddenByDefault: true),
])
@@ -45,7 +51,26 @@ public static function configure(Table $table): Table
->icon(Heroicon::OutlinedCheck)
->color('success')
->visible(fn (ChannelTask $record): bool => $record->status === ChannelTaskStatus::Open)
->action(fn (ChannelTask $record) => $record->complete(auth()->user()->name)),
->modalHeading(fn (ChannelTask $record): string => ($record->action === ChannelTaskAction::Block ? 'Sperre in ' : 'Freigabe in ').$record->channel->name.' erledigt')
->modalDescription('Was können Sie sagen? Ein bereitgestellter Kalender beweist nicht, dass das Portal ihn schon übernommen hat.')
->fillForm(['proof' => ChannelTaskProof::Initiated->value])
->schema(fn (ChannelTask $record): array => [
Radio::make('proof')->hiddenLabel()->required()
->options(collect(ChannelTaskProof::cases())->mapWithKeys(fn (ChannelTaskProof $proof): array => [$proof->value => $proof->question($record->action === ChannelTaskAction::Block)])->all()),
Textarea::make('note')->label('Notiz (optional)')->placeholder('z. B. „im Vermieterkalender rot markiert“')->rows(2),
])
->action(fn (ChannelTask $record, array $data) => $record->complete(auth()->user()->name, ChannelTaskProof::from($data['proof']), $data['note'] ?? null)),
Action::make('prove')
->label('Nachweis ergänzen')
->icon(Heroicon::OutlinedShieldCheck)
->color('gray')
->visible(fn (ChannelTask $record): bool => $record->status === ChannelTaskStatus::Done && $record->proof !== ChannelTaskProof::Confirmed)
->schema(fn (ChannelTask $record): array => [
Radio::make('proof')->hiddenLabel()->required()
->options(collect([ChannelTaskProof::Observed, ChannelTaskProof::Confirmed])->mapWithKeys(fn (ChannelTaskProof $proof): array => [$proof->value => $proof->question($record->action === ChannelTaskAction::Block)])->all()),
Textarea::make('note')->label('Notiz (optional)')->rows(2),
])
->action(fn (ChannelTask $record, array $data) => $record->prove(ChannelTaskProof::from($data['proof']), auth()->user()->name, $data['note'] ?? null)),
Action::make('dismiss')
->label('Verwerfen')
->icon(Heroicon::OutlinedXMark)
@@ -3,6 +3,7 @@
namespace App\Filament\Resources\Channels\Schemas;
use App\Channels\ChannelRegistry;
use App\Enums\CaseIntakeMode;
use App\Enums\ChannelBookingModel;
use App\Enums\ChannelEchoBehavior;
use App\Enums\ChannelExportMode;
@@ -55,6 +56,13 @@ public static function configure(Schema $schema, bool $selectProperty = false):
Select::make('status')->label('Kanalstatus')->options(ChannelStatus::class)->default(ChannelStatus::Setup)->required(),
Select::make('booking_model')->label('Was kommt über dieses Portal?')->options(ChannelBookingModel::class)->default(ChannelBookingModel::Mixed)->required()
->helperText('„Portalbuchung“ und „Gemischt“ gelten als Sofortbuchung: automatische Angebote für diese Wohnung warten, bis das Portal unseren Kalender abgerufen hat. „Vermittlung / Anfrage“: keine Sofortbuchung.'),
Select::make('case_intake')
->label('Erkannte Buchungen automatisch als Vorgang übernehmen?')
->options(CaseIntakeMode::class)
->default(CaseIntakeMode::Off)
->required()
->helperText('Zuerst „Beobachten“: Dann entsteht nichts, aber das Eingangsprotokoll (Expertenansicht) zeigt, welche Vorgänge entstanden wären. Unklare Belegungen und Meldungen zu gebuchten Vorgängen erscheinen unter „Zu erledigen“. Unterlagen gehen nie ohne Ihre Freigabe hinaus.')
->columnSpanFull(),
...self::processSections(),
Select::make('connector')
->label('Kalenderanbindung')
@@ -0,0 +1,83 @@
<?php
namespace App\Filament\Resources\IntakeObservations;
use App\Enums\CaseIntakeMode;
use App\Enums\IntakeOutcome;
use App\Filament\Concerns\FollowsAdminMode;
use App\Filament\Resources\Bookings\BookingResource;
use App\Filament\Resources\IntakeObservations\Pages\ListIntakeObservations;
use App\Models\Channel;
use App\Models\IntakeObservation;
use BackedEnum;
use Filament\Resources\Resource;
use Filament\Support\Icons\Heroicon;
use Filament\Tables\Columns\IconColumn;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
use UnitEnum;
/**
* The intake record (expert view): what came in over each portal, what the intake recognised, whether it acted or only
* observed, and why. Read only – the work itself happens under "Zu erledigen" and on the case page.
*/
class IntakeObservationResource extends Resource
{
use FollowsAdminMode;
protected static ?string $model = IntakeObservation::class;
protected static string|BackedEnum|null $navigationIcon = Heroicon::OutlinedInboxArrowDown;
protected static string|UnitEnum|null $navigationGroup = 'System';
protected static ?string $navigationLabel = 'Eingangsprotokoll';
protected static ?string $modelLabel = 'Eingang';
protected static ?string $pluralModelLabel = 'Eingangsprotokoll';
protected static ?int $navigationSort = 20;
public static function canCreate(): bool
{
return false;
}
public static function table(Table $table): Table
{
return $table
->description('Was über die Portale hereinkam und was daraus wurde. „Nur protokolliert“ heißt: Das Portal steht auf „Beobachten“ (oder es war nichts zu tun) – es ist nichts entstanden.')
->defaultSort('occurred_at', 'desc')
->modifyQueryUsing(fn ($query) => $query->with(['channel', 'booking']))
->columns([
TextColumn::make('occurred_at')->label('Wann')->dateTime('d.m.Y H:i')->sortable(),
TextColumn::make('channel.name')->label('Portal')->description(fn (IntakeObservation $record): string => $record->sourceLabel()),
TextColumn::make('period')->label('Zeitraum')->state(fn (IntakeObservation $record): ?string => $record->starts_on ? $record->starts_on->format('d.m.').'–'.$record->ends_on?->format('d.m.Y') : null)->placeholder('–'),
TextColumn::make('outcome')->label('Ergebnis')->badge()->description(fn (IntakeObservation $record): string => implode(' ', (array) $record->reasons))->wrap(),
TextColumn::make('case_type')->label('Art')->formatStateUsing(fn (?string $state): string => strtoupper((string) $state))->placeholder('–'),
IconColumn::make('applied')->label('Ausgeführt')->boolean()->tooltip('Ja: Vorgang angelegt, zugeordnet, Aufgabe erstellt oder zur Klärung vorgelegt. Nein: nur protokolliert.'),
TextColumn::make('mode')->label('Einstellung')->formatStateUsing(fn (CaseIntakeMode $state): string => match ($state) {
CaseIntakeMode::Observe => 'Beobachten',
CaseIntakeMode::Create => 'Anlegen',
CaseIntakeMode::Continue => 'Anlegen + weiter',
CaseIntakeMode::Off => 'Aus',
})->toggleable(),
TextColumn::make('reference')->label('Buchungsnr.')->placeholder('–')->toggleable(),
TextColumn::make('booking.reference')->label('Vorgang')->placeholder('–')
->url(fn (IntakeObservation $record): ?string => $record->booking ? BookingResource::getUrl('view', ['record' => $record->booking]) : null),
TextColumn::make('missing')->label('Fehlt noch')->state(fn (IntakeObservation $record): string => implode(', ', (array) $record->missing))->placeholder('–')->wrap()->toggleable(isToggledHiddenByDefault: true),
])
->filters([
SelectFilter::make('channel_id')->label('Portal')->options(fn (): array => Channel::query()->orderBy('name')->pluck('name', 'id')->all()),
SelectFilter::make('outcome')->label('Ergebnis')->options(IntakeOutcome::class),
SelectFilter::make('applied')->label('Ausgeführt')->options(['1' => 'ja', '0' => 'nur protokolliert']),
]);
}
public static function getPages(): array
{
return ['index' => ListIntakeObservations::route('/')];
}
}
@@ -0,0 +1,11 @@
<?php
namespace App\Filament\Resources\IntakeObservations\Pages;
use App\Filament\Resources\IntakeObservations\IntakeObservationResource;
use Filament\Resources\Pages\ListRecords;
class ListIntakeObservations extends ListRecords
{
protected static string $resource = IntakeObservationResource::class;
}
@@ -3,7 +3,9 @@
namespace App\Filament\Resources\PortalOccupations\Pages;
use App\Filament\Resources\PortalOccupations\PortalOccupationResource;
use Filament\Actions\ActionGroup;
use Filament\Resources\Pages\ViewRecord;
use Filament\Support\Icons\Heroicon;
class ViewPortalOccupation extends ViewRecord
{
@@ -16,6 +18,9 @@ public function getTitle(): string
protected function getHeaderActions(): array
{
return PortalOccupationResource::occupationActions();
$actions = PortalOccupationResource::occupationActions();
[$primary, $more] = [array_slice($actions, 0, 3), array_slice($actions, 3)];
return [...$primary, ActionGroup::make($more)->label('Weitere Möglichkeiten')->icon(Heroicon::OutlinedEllipsisHorizontal)->button()->color('gray')];
}
}
@@ -4,6 +4,7 @@
use App\Actions\ClassifyPortalOccupation;
use App\Actions\OpenPortalFile;
use App\Actions\ResolveChannelOccupation;
use App\Enums\OccupationKind;
use App\Exceptions\ReservationException;
use App\Filament\Actions\AssignGuestAction;
@@ -15,11 +16,13 @@
use App\Filament\Resources\PortalOccupations\Pages\ManagePortalOccupations;
use App\Filament\Resources\PortalOccupations\Pages\ViewPortalOccupation;
use App\Models\BlockedPeriod;
use App\Models\Booking;
use App\Models\Channel;
use BackedEnum;
use Filament\Actions\Action;
use Filament\Actions\ActionGroup;
use Filament\Actions\ViewAction;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Select;
use Filament\Infolists\Components\TextEntry;
use Filament\Notifications\Notification;
@@ -80,19 +83,85 @@ public static function table(Table $table): Table
TextColumn::make('channel.name')->label('Importkanal'),
TextColumn::make('property.name')->label('Wohnung')->toggleable(),
TextColumn::make('needs_review')->label('Prüffall')->formatStateUsing(fn (bool $state): string => $state ? 'Bitte prüfen' : '–')->description(fn (BlockedPeriod $record): ?string => $record->review_note),
])->recordActions([Action::make('fileLink')->label('Als Buchung übernehmen')->icon(Heroicon::OutlinedFolderPlus)->button()->color('primary')->visible(fn (BlockedPeriod $record): bool => static::canOpenFile($record))->url(fn (BlockedPeriod $record): string => static::getUrl('view', ['record' => $record])), static::showFileAction()->button(), ViewAction::make(), ActionGroup::make(static::occupationActions(withFile: false))->label('Weitere Aktionen')]);
])->recordActions([Action::make('clarifyLink')->label('Klären')->icon(Heroicon::OutlinedQuestionMarkCircle)->button()->color('warning')->visible(fn (BlockedPeriod $record): bool => static::isUnclear($record))->url(fn (BlockedPeriod $record): string => static::getUrl('view', ['record' => $record])), Action::make('fileLink')->label('Als Buchung übernehmen')->icon(Heroicon::OutlinedFolderPlus)->button()->color('primary')->visible(fn (BlockedPeriod $record): bool => static::canOpenFile($record))->url(fn (BlockedPeriod $record): string => static::getUrl('view', ['record' => $record])), static::showFileAction()->button(), ViewAction::make(), ActionGroup::make(static::occupationActions(withFile: false))->label('Weitere Aktionen')]);
}
public static function occupationActions(bool $withFile = true): array
{
return [
...($withFile ? [static::openFileAction(), static::showFileAction()] : []),
...($withFile ? [static::clarifyAction(), static::openFileAction(), static::showFileAction()] : []),
AssignGuestAction::make(),
static::classificationAction(),
...BlockedPeriodResource::portalActions(),
];
}
/**
* Whether the entry still waits for the landlord's answer (it is listed under "Zu erledigen").
*/
public static function isUnclear(BlockedPeriod $record): bool
{
return ! $record->trashed() && BlockedPeriod::query()->unclear()->whereKey($record->id)->exists();
}
/**
* The one question for an unclear portal entry, in plain words: is it a booking (then it becomes a case), does it
* belong to a case that already exists, or is it no booking at all? The detailed tools stay under "Weitere".
*/
public static function clarifyAction(): Action
{
return Action::make('clarify')->label('Klären: Was ist das?')->icon(Heroicon::OutlinedQuestionMarkCircle)->color('primary')
->visible(fn (BlockedPeriod $record): bool => static::isUnclear($record) && ! $record->is_representation)
->authorize(fn (BlockedPeriod $record): bool => auth()->user()?->can('update', $record) ?? false)
->modalHeading(fn (BlockedPeriod $record): string => 'Belegung von '.($record->channel?->name ?? 'einem Portal').' am '.$record->starts_on->format('d.m.').'–'.$record->ends_on->format('d.m.Y'))
->modalDescription(fn (BlockedPeriod $record): string => 'Für diesen Zeitraum wurde eine Belegung gemeldet. Bitte wählen Sie, was es ist.'.($record->review_note ? ' Hinweis: '.$record->review_note : ''))
->modalSubmitActionLabel('Übernehmen')
->schema(fn (BlockedPeriod $record): array => [
Radio::make('answer')->hiddenLabel()->required()->live()->options(array_filter([
'booking' => static::canOpenFile($record) ? 'Eine Buchung über '.($record->channel?->name ?? 'das Portal').' – als Vorgang übernehmen' : null,
'case' => static::sameNightCases($record) !== [] ? 'Gehört zu einem Vorgang, der schon da ist' : null,
'block' => 'Keine Buchung: Sperre, eigene Nutzung oder Spiegelung eines anderen Portals',
])),
Select::make('booking_id')->label('Vorgang')->options(fn (): array => static::sameNightCases($record))
->visible(fn (Get $get): bool => $get('answer') === 'case')->required(fn (Get $get): bool => $get('answer') === 'case'),
])
->action(function (BlockedPeriod $record, array $data, OpenPortalFile $open, ResolveChannelOccupation $resolve, ClassifyPortalOccupation $classify) {
try {
if ($data['answer'] === 'booking') {
$booking = $open->handle($record);
Notification::make()->title('Als Buchung übernommen')->success()->send();
return redirect(BookingResource::getUrl('view', ['record' => $booking]));
}
if ($data['answer'] === 'case') {
$resolve->handle($record, 'booking', (int) $data['booking_id']);
Notification::make()->title('Dem Vorgang zugeordnet')->success()->send();
return null;
}
$classify->handle($record, OccupationKind::Block);
$record->refresh()->forceFill(['needs_review' => false, 'reviewed_at' => now(), 'review_note' => 'Persönlich als Sperre eingeordnet.'])->save();
Notification::make()->title('Als Sperre eingeordnet')->success()->send();
} catch (ReservationException $exception) {
Notification::make()->title('Nicht möglich')->body($exception->getMessage())->danger()->send();
}
return null;
});
}
/**
* Cases of the same property with exactly these nights (the only ones the entry may belong to).
*
* @return array<int, string>
*/
public static function sameNightCases(BlockedPeriod $record): array
{
return Booking::query()->occupying()->with('guest')->where('property_id', $record->property_id)
->whereDate('arrival', $record->starts_on)->whereDate('departure', $record->ends_on)->get()
->mapWithKeys(fn (Booking $booking): array => [$booking->id => $booking->reference.' · '.$booking->guestName().' · '.$booking->bookingChannelLabel()])->all();
}
/**
* Takes a reservation from a portal calendar over as a case (no second, manual "file").
*/
@@ -95,6 +95,9 @@ public static function configure(Schema $schema): Schema
->label('Endreinigung & Service (einmalig)')
->required()
->default(0),
EuroInput::make('tourist_tax_rate')
->label('Kurabgabe je Person und Nacht')
->helperText('Ihr Satz laut Gemeinde. Wird bei eigener Nutzung und privaten Aufenthalten als eigene Position berechnet; Befreiungen tragen Sie im Vorgang ein. Leer lassen: keine Berechnung.'),
]),
Section::make('Zahlungsbedingungen')
->columns(2)
+50
View File
@@ -0,0 +1,50 @@
<?php
namespace App\Http\Controllers;
use App\Actions\ChangeBooking;
use App\Enums\ChangeStatus;
use App\Exceptions\ReservationException;
use App\Mail\ChangeAnswered;
use App\Models\BookingChange;
use App\Support\Settings;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;
/**
* The guest's page for a proposed change of a booking (signed link): see it, accept it or decline it. Only the acceptance
* here makes the change binding; it is recorded with time and (hashed) address.
*/
class ChangeController extends Controller
{
public function show(BookingChange $change): View
{
return view('change', ['change' => $change, 'booking' => $change->booking]);
}
public function accept(Request $request, BookingChange $change, ChangeBooking $changes): RedirectResponse
{
$request->validate(['agree' => ['accepted']], ['agree.accepted' => 'Bitte bestätigen Sie, dass Sie mit der Änderung einverstanden sind.']);
try {
$changes->accept($change, $request->ip());
} catch (ReservationException $exception) {
return back()->with('change.error', $exception->getMessage());
}
rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new ChangeAnswered($change->fresh(), accepted: true)));
return back()->with('change.success', 'Vielen Dank – die Änderung ist jetzt verbindlich.');
}
public function decline(BookingChange $change, ChangeBooking $changes): RedirectResponse
{
if ($change->status === ChangeStatus::Proposed) {
$changes->decline($change, request()->ip());
rescue(fn () => Mail::to(Settings::notificationRecipients())->send(new ChangeAnswered($change->fresh(), accepted: false)));
}
return back()->with('change.success', 'Sie haben die Änderung abgelehnt. Ihre Buchung bleibt unverändert.');
}
}
+67
View File
@@ -0,0 +1,67 @@
<?php
namespace App\Listeners;
use App\Models\Tenant;
use App\Support\Settings;
use Illuminate\Mail\Events\MessageSending;
use Illuminate\Support\Facades\Log;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Email;
/**
* The one gate every outgoing e-mail passes – whichever mailer, mailable or notification sent it (Laravel fires
* MessageSending for every message right before the transport). In test operation it replaces every recipient (To, Cc,
* Bcc) by the test recipient; when no test recipient can be determined, the mail is not sent at all. Only a landlord
* switched live (and no server override) lets mails reach their real recipients.
*
* The operating mode is read fresh from the database for every mail, so a switch in the admin applies at once, also in
* long-running processes. Without any landlord the installation counts as being in test operation.
*/
class EnforceMailTestMode
{
public const ORIGINAL_RECIPIENTS_HEADER = 'X-Fewo-Testbetrieb-Original';
/**
* @return false|null false stops the mail; null lets it go on
*/
public function handle(MessageSending $event): ?bool
{
$message = $event->message;
$tenant = Settings::tenant();
$tenant = $tenant instanceof Tenant ? ($tenant->fresh() ?? $tenant) : null;
$override = config('fewo.mail_redirect_to');
if (blank($override) && $tenant?->isLive()) {
return null;
}
$redirect = Settings::mailRedirectFor($tenant);
if (blank($redirect) || filter_var($redirect, FILTER_VALIDATE_EMAIL) === false) {
// Test operation without anybody to redirect to: never fall through to the real recipients.
Log::warning('E-Mail im Testbetrieb nicht versendet: keine Testadresse eingerichtet.', ['subject' => $message instanceof Email ? $message->getSubject() : null, 'tenant' => $tenant?->id]);
return false;
}
if (! $message instanceof Email) {
Log::warning('E-Mail im Testbetrieb nicht versendet: unbekannter Nachrichtentyp.', ['type' => $message::class]);
return false;
}
$original = collect([...$message->getTo(), ...$message->getCc(), ...$message->getBcc()])
->map(fn (Address $address): string => $address->getAddress())->unique()->implode(', ');
$headers = $message->getHeaders();
$headers->remove('Cc');
$headers->remove('Bcc');
$headers->remove(self::ORIGINAL_RECIPIENTS_HEADER);
$message->to($redirect);
if ($original !== '') {
$headers->addTextHeader(self::ORIGINAL_RECIPIENTS_HEADER, mb_substr($original, 0, 900));
}
return null;
}
}
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Mail;
use App\Models\Booking;
use App\Models\BookingChange;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* Confirms a change that was already agreed with the guest – information about what now applies, not a request for
* consent (package 5).
*/
class BookingChanged extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking, public BookingChange $change) {}
public function envelope(): Envelope
{
return new Envelope(
subject: 'Änderung Ihrer Buchung '.$this->booking->reference,
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
public function content(): Content
{
return new Content(markdown: 'mail.booking-changed');
}
}
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Mail;
use App\Models\BookingChange;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* Tells the landlord how the guest answered a proposed change.
*/
class ChangeAnswered extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public BookingChange $change, public bool $accepted) {}
public function envelope(): Envelope
{
return new Envelope(subject: ($this->accepted ? 'Änderung angenommen: ' : 'Änderung abgelehnt: ').$this->change->booking->reference);
}
public function content(): Content
{
return new Content(markdown: 'mail.change-answered');
}
}
+36
View File
@@ -0,0 +1,36 @@
<?php
namespace App\Mail;
use App\Models\Booking;
use App\Models\BookingChange;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* Proposes a change to the guest: nothing has changed yet; the guest accepts or declines through the signed link
* (package 5). Only the guest's acceptance makes it binding.
*/
class ChangeProposed extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking, public BookingChange $change, public string $url) {}
public function envelope(): Envelope
{
return new Envelope(
subject: 'Vorschlag zur Änderung Ihrer Buchung '.$this->booking->reference,
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
public function content(): Content
{
return new Content(markdown: 'mail.change-proposed');
}
}
+46
View File
@@ -0,0 +1,46 @@
<?php
namespace App\Mail;
use App\Documents\RentalContract;
use App\Models\Booking;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
/**
* The confirmation of a private stay (A6, on request): the stay, no rental contract (package 6).
*/
class StayConfirmed extends Mailable
{
use Queueable, SerializesModels;
public function __construct(public Booking $booking) {}
public function envelope(): Envelope
{
return new Envelope(
subject: 'Bestätigung Ihres Aufenthalts '.$this->booking->reference,
replyTo: [new Address(config('fewo.owner.email'), config('fewo.owner.name'))],
);
}
public function content(): Content
{
return new Content(markdown: 'mail.stay-confirmed');
}
/**
* @return list<Attachment>
*/
public function attachments(): array
{
$path = app(RentalContract::class)->absolutePath($this->booking);
return $path ? [Attachment::fromPath($path)->as("Aufenthaltsbestaetigung-{$this->booking->reference}.pdf")->withMime('application/pdf')] : [];
}
}
+80 -3
View File
@@ -7,6 +7,8 @@
use App\Enums\BookingTaskKind;
use App\Enums\CaseType;
use App\Enums\IntakeKind;
use App\Enums\InternalKind;
use App\Enums\PaymentKind;
use App\Enums\ProcessingMode;
use App\Enums\ReferralSource;
use App\Enums\Responsibility;
@@ -91,13 +93,19 @@
'balance_requested_at',
'balance_reminded_at',
'arrival_info_sent_at',
'internal_kind',
'occasion',
'tourist_tax_persons',
'tourist_tax_note',
'portal_cancellation_requested_at',
'export_uid',
])]
class Booking extends Model
{
/** @use HasFactory<BookingFactory> */
use BelongsToTenant, HasChannelProvenance, HasFactory;
public const DIRECT_SOURCES = ['website', 'manual', 'phone', 'direct', 'email'];
public const DIRECT_SOURCES = ['website', 'manual', 'phone', 'direct', 'email', 'internal'];
public function isDirect(): bool
{
@@ -177,6 +185,8 @@ protected function casts(): array
'contact_requested_at' => 'immutable_datetime',
'guest_confirmed_at' => 'immutable_datetime',
'archived_at' => 'immutable_datetime',
'internal_kind' => InternalKind::class,
'portal_cancellation_requested_at' => 'immutable_datetime',
];
}
@@ -267,6 +277,7 @@ public function bookingChannelLabel(): string
'phone' => 'Telefon',
'email' => 'E-Mail',
'direct' => 'Direkt',
'internal' => 'Eigene Belegung',
default => $this->source,
};
}
@@ -336,7 +347,73 @@ public function payments(): HasMany
*/
public function paidAmount(): int
{
return (int) ($this->relationLoaded('payments') ? $this->payments->sum('amount') : $this->payments()->sum('amount'));
return $this->sumOfPayments([PaymentKind::Guest, PaymentKind::GuestViaPortal, PaymentKind::Refund]);
}
/**
* What the guest paid us directly, less refunds (money on our account from the guest).
*/
public function paidToUs(): int
{
return $this->sumOfPayments([PaymentKind::Guest, PaymentKind::Refund]);
}
/**
* What the guest paid to the portal according to the portal (no money on our account).
*/
public function paidViaPortal(): int
{
return $this->sumOfPayments([PaymentKind::GuestViaPortal]);
}
/**
* What the portal paid out to us.
*/
public function payoutsReceived(): int
{
return $this->sumOfPayments([PaymentKind::PortalPayout]);
}
/**
* @param list<PaymentKind> $kinds
*/
private function sumOfPayments(array $kinds): int
{
$payments = $this->relationLoaded('payments') ? $this->payments : $this->payments()->get();
return (int) $payments->filter(fn (Payment $payment): bool => in_array($payment->kind ?? PaymentKind::Guest, $kinds, true))->sum('amount');
}
/**
* @return HasOne<Cancellation, $this>
*/
public function cancellation(): HasOne
{
return $this->hasOne(Cancellation::class);
}
/**
* @return HasMany<CaseAmount, $this>
*/
public function amounts(): HasMany
{
return $this->hasMany(CaseAmount::class)->orderBy('id');
}
/**
* @return HasMany<BookingChange, $this>
*/
public function changes(): HasMany
{
return $this->hasMany(BookingChange::class)->orderBy('id');
}
/**
* Own use, private stay or block (A6).
*/
public function isInternal(): bool
{
return $this->intake === IntakeKind::Internal;
}
/**
@@ -366,7 +443,7 @@ public function requiresFullPayment(): bool
*/
public function wantsPaymentTasks(): bool
{
return $this->process()->payments() === Responsibility::Landlord && $this->total !== null && $this->total > 0;
return ! $this->isInternal() && $this->process()->payments() === Responsibility::Landlord && $this->total !== null && $this->total > 0;
}
/**
+56
View File
@@ -0,0 +1,56 @@
<?php
namespace App\Models;
use App\Enums\ChangeBasis;
use App\Enums\ChangeStatus;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* One change of a booking (package 5): what it was before and after, who asked and why, from when, and on which basis
* the guest agreed – or, as long as it is only proposed, that the guest still has to agree.
*/
#[Fillable(['booking_id', 'status', 'requested_by', 'basis', 'reason', 'effective_on', 'agreed_at', 'agreed_by', 'before', 'after', 'consequences', 'expires_at', 'decided_at', 'decision_ip_hash', 'applied_at', 'confirmation_sent_at', 'recorded_by'])]
class BookingChange extends Model
{
use BelongsToTenant;
public const REQUESTERS = ['guest' => 'Der Gast', 'landlord' => 'Wir (Vermieter)', 'portal' => 'Das Portal'];
/**
* @return array<string, string>
*/
protected function casts(): array
{
return [
'status' => ChangeStatus::class,
'basis' => ChangeBasis::class,
'effective_on' => 'immutable_date',
'agreed_at' => 'immutable_datetime',
'before' => 'array',
'after' => 'array',
'consequences' => 'array',
'expires_at' => 'immutable_datetime',
'decided_at' => 'immutable_datetime',
'applied_at' => 'immutable_datetime',
'confirmation_sent_at' => 'immutable_datetime',
];
}
/** @return BelongsTo<Booking, $this> */
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
/**
* The change in one line, e.g. "07.11.–10.11.2026 → 07.11.–12.11.2026 · 2 → 3 Personen · 368,00 € → 450,00 €".
*/
public function summary(): string
{
return implode(' · ', (array) ($this->consequences['summary'] ?? []));
}
}
+1 -1
View File
@@ -11,7 +11,7 @@
* The record of a cancelled booking: when, how many days before arrival, the cost proposed by the cancellation rule
* and the amount the landlord finally charges. Cancelled bookings stay in the system for this history.
*/
#[Fillable(['booking_id', 'cancelled_on', 'initiated_by', 'has_policy', 'policy_name', 'days_before', 'percent', 'base_amount', 'calculated_fee', 'final_fee', 'paid_amount', 'status', 'note', 'settled_at'])]
#[Fillable(['booking_id', 'cancelled_on', 'initiated_by', 'has_policy', 'policy_name', 'days_before', 'percent', 'base_amount', 'calculated_fee', 'final_fee', 'paid_amount', 'status', 'note', 'settled_at', 'reason', 'recorded_by'])]
class Cancellation extends Model
{
use BelongsToTenant;
+50
View File
@@ -0,0 +1,50 @@
<?php
namespace App\Models;
use App\Enums\AmountKind;
use App\Models\Concerns\BelongsToTenant;
use App\Process\CaseLog;
use App\Support\Money;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* An amount of a case as a source states it (package 8): the portal's price positions, what it keeps as commission,
* what it announces to pay out, instalments of the guest. Stored as stated – contradicting statements stand side by
* side, and nothing is derived from them.
*/
#[Fillable(['booking_id', 'kind', 'label', 'amount', 'source', 'stated_on', 'due_on', 'note', 'recorded_by'])]
class CaseAmount extends Model
{
use BelongsToTenant;
protected static function booted(): void
{
static::created(function (CaseAmount $amount): void {
if ($amount->booking !== null) {
CaseLog::record($amount->booking, 'amount', ($amount->label ?: $amount->kind->getLabel()).': '.Money::format($amount->amount).($amount->source ? ' laut '.$amount->source : ''), data: ['case_amount_id' => $amount->id]);
}
});
}
/**
* @return array<string, string>
*/
protected function casts(): array
{
return ['kind' => AmountKind::class, 'amount' => 'integer', 'stated_on' => 'immutable_date', 'due_on' => 'immutable_date'];
}
/** @return BelongsTo<Booking, $this> */
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
public function title(): string
{
return $this->label ?: $this->kind->getLabel();
}
}
+4 -2
View File
@@ -4,6 +4,7 @@
use App\Channels\ChannelRegistry;
use App\Channels\Contracts\ChannelConnector;
use App\Enums\CaseIntakeMode;
use App\Enums\ChannelBookingModel;
use App\Enums\ChannelEchoBehavior;
use App\Enums\ChannelExportMode;
@@ -26,7 +27,7 @@
* 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', 'status', 'booking_model', 'import_enabled', 'export_enabled', 'export_mode', 'external_poll_minutes', 'echo_behavior', 'echo_notes', 'operating_notes', 'portal_verified_at', 'payment_tasks_inquiry', 'payment_tasks_reservation', 'contract_template_id', 'contract_template_reservation_id', 'process_overrides'])]
#[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', 'payment_tasks_inquiry', 'payment_tasks_reservation', 'contract_template_id', 'contract_template_reservation_id', 'process_overrides', 'case_intake'])]
#[Hidden(['export_token', 'previous_export_token', 'export_snapshot', 'settings', 'ical_analysis'])]
class Channel extends Model
{
@@ -36,7 +37,7 @@ class Channel extends Model
protected $attributes = [
'status' => 'setup', 'booking_model' => 'mixed', 'import_enabled' => false,
'export_enabled' => false, 'export_mode' => 'test',
'echo_behavior' => 'unverified',
'echo_behavior' => 'unverified', 'case_intake' => 'off',
];
protected static function booted(): void
@@ -63,6 +64,7 @@ protected function casts(): array
return [
'settings' => 'array',
'process_overrides' => 'array',
'case_intake' => CaseIntakeMode::class,
'ical_analysis' => 'encrypted:array',
'ical_analyzed_at' => 'immutable_datetime',
'ical_rules' => 'array',
+37 -2
View File
@@ -4,6 +4,7 @@
use App\Availability\AvailabilityChecker;
use App\Enums\ChannelTaskAction;
use App\Enums\ChannelTaskProof;
use App\Enums\ChannelTaskStatus;
use App\Models\Concerns\BelongsToTenant;
use Database\Factories\ChannelTaskFactory;
@@ -18,7 +19,7 @@
* A change that has to be made by hand (or by an external automation) on a portal that
* cannot be kept in sync fast enough by calendar feeds, e.g. because of instant booking.
*/
#[Fillable(['channel_id', 'action', 'starts_on', 'ends_on', 'reason', 'status', 'completed_by', 'completed_at', 'reminded_at', 'automation_sent_at', 'automation_error'])]
#[Fillable(['channel_id', 'action', 'starts_on', 'ends_on', 'reason', 'status', 'completed_by', 'completed_at', 'reminded_at', 'automation_sent_at', 'automation_error', 'proof', 'proof_note', 'proof_at', 'proof_by'])]
class ChannelTask extends Model
{
/** @use HasFactory<ChannelTaskFactory> */
@@ -39,6 +40,8 @@ protected function casts(): array
'completed_at' => 'immutable_datetime',
'reminded_at' => 'immutable_datetime',
'automation_sent_at' => 'immutable_datetime',
'proof' => ChannelTaskProof::class,
'proof_at' => 'immutable_datetime',
];
}
@@ -60,7 +63,10 @@ protected function open(Builder $query): Builder
return $query->where('status', ChannelTaskStatus::Open);
}
public function complete(string $completedBy): void
/**
* Completes the task with the proof the person can give (at least: the change was made or started).
*/
public function complete(string $completedBy, ChannelTaskProof $proof = ChannelTaskProof::Initiated, ?string $note = null): void
{
if ($this->status !== ChannelTaskStatus::Open) {
return;
@@ -74,9 +80,38 @@ public function complete(string $completedBy): void
'status' => ChannelTaskStatus::Done,
'completed_by' => $completedBy,
'completed_at' => now(),
'proof' => $proof,
'proof_note' => filled($note) ? trim($note) : null,
'proof_at' => now(),
'proof_by' => $completedBy,
]);
}
/**
* Raises the proof of a completed task (e.g. the block was later seen in the portal); never lowers it.
*/
public function prove(ChannelTaskProof $proof, string $by, ?string $note = null): void
{
$order = array_flip(array_map(fn (ChannelTaskProof $case): string => $case->value, ChannelTaskProof::cases()));
if ($this->status !== ChannelTaskStatus::Done || ($this->proof !== null && $order[$proof->value] <= $order[$this->proof->value])) {
return;
}
$this->update(['proof' => $proof, 'proof_note' => filled($note) ? trim($note) : $this->proof_note, 'proof_at' => now(), 'proof_by' => $by]);
}
/**
* The state of the task in plain words, including how far it is proven.
*/
public function proofLabel(): string
{
return match ($this->status) {
ChannelTaskStatus::Open => 'noch offen',
ChannelTaskStatus::Dismissed => 'verworfen',
ChannelTaskStatus::Done => ($this->proof ?? ChannelTaskProof::Initiated)->getLabel().($this->proof_note ? ' ('.$this->proof_note.')' : ''),
};
}
/**
* Human readable period, e.g. "14.06.2027 – 21.06.2027".
*/
+72
View File
@@ -0,0 +1,72 @@
<?php
namespace App\Models;
use App\Enums\CaseIntakeMode;
use App\Enums\IntakeOutcome;
use App\Models\Concerns\BelongsToTenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* One entry of the intake record: an incoming portal event, what the intake recognised and whether it acted. The same
* event with the same result is recorded once (fingerprint), however often the calendar is read or the mail arrives.
*/
#[Fillable(['channel_id', 'blocked_period_id', 'portal_email_id', 'booking_id', 'fingerprint', 'source', 'mode', 'outcome', 'applied', 'case_type', 'starts_on', 'ends_on', 'reference', 'reasons', 'missing', 'occurred_at'])]
class IntakeObservation extends Model
{
use BelongsToTenant;
public const SOURCE_CALENDAR = 'calendar';
public const SOURCE_MAIL = 'mail';
public const SOURCE_ADOPTION = 'adoption';
/**
* Get the attributes that should be cast.
*
* @return array<string, string>
*/
protected function casts(): array
{
return [
'mode' => CaseIntakeMode::class,
'outcome' => IntakeOutcome::class,
'applied' => 'boolean',
'starts_on' => 'immutable_date',
'ends_on' => 'immutable_date',
'reasons' => 'array',
'missing' => 'array',
'occurred_at' => 'immutable_datetime',
];
}
/** @return BelongsTo<Channel, $this> */
public function channel(): BelongsTo
{
return $this->belongsTo(Channel::class);
}
/** @return BelongsTo<Booking, $this> */
public function booking(): BelongsTo
{
return $this->belongsTo(Booking::class);
}
/** @return BelongsTo<BlockedPeriod, $this> */
public function blockedPeriod(): BelongsTo
{
return $this->belongsTo(BlockedPeriod::class)->withTrashed();
}
public function sourceLabel(): string
{
return match ($this->source) {
self::SOURCE_MAIL => 'Portal-E-Mail',
self::SOURCE_ADOPTION => 'Bestandsübernahme',
default => 'Portalkalender',
};
}
}
+6 -3
View File
@@ -2,6 +2,7 @@
namespace App\Models;
use App\Enums\PaymentKind;
use App\Enums\PaymentMethod;
use App\Models\Concerns\BelongsToTenant;
use App\Process\CaseLog;
@@ -13,9 +14,10 @@
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* A received payment (negative amount = refund), in euro cents.
* A payment in euro cents (negative amount = refund) and its kind: the guest paid us, the portal reports the guest paid
* it, the portal paid out to us, or we refunded the guest ({@see PaymentKind}).
*/
#[Fillable(['booking_id', 'amount', 'paid_on', 'method', 'note', 'recorded_by'])]
#[Fillable(['booking_id', 'amount', 'paid_on', 'method', 'note', 'recorded_by', 'kind', 'source'])]
class Payment extends Model
{
/** @use HasFactory<PaymentFactory> */
@@ -25,7 +27,7 @@ protected static function booted(): void
{
static::created(function (Payment $payment): void {
if ($payment->booking !== null) {
CaseLog::record($payment->booking, 'payment', ($payment->amount < 0 ? 'Erstattung ' : 'Zahlung ').Money::format(abs($payment->amount)).' erfasst', data: ['payment_id' => $payment->id]);
CaseLog::record($payment->booking, 'payment', ($payment->kind ?? PaymentKind::Guest)->getLabel().': '.Money::format(abs($payment->amount)).($payment->source ? ' ('.$payment->source.')' : ''), data: ['payment_id' => $payment->id]);
}
});
}
@@ -40,6 +42,7 @@ protected function casts(): array
return [
'paid_on' => 'immutable_date',
'method' => PaymentMethod::class,
'kind' => PaymentKind::class,
];
}
+1
View File
@@ -28,6 +28,7 @@
'included_guests',
'extra_guest_fee_per_night',
'cleaning_fee',
'tourist_tax_rate',
'deposit_percent',
'balance_due_days_before_arrival',
'hold_hours',
+138
View File
@@ -0,0 +1,138 @@
<?php
namespace App\Pricing;
use App\Enums\AmountKind;
use App\Enums\Responsibility;
use App\Models\Booking;
use App\Models\CaseAmount;
use Illuminate\Support\Collection;
/**
* The money of a case as four separate questions (package 8, K01): what the guest owes and to whom, what the guest has
* paid (to us or – according to the portal – to the portal), what the portal still has to pay out to us, and what has
* really arrived on our account. Every figure comes from a stated amount or a recorded payment; nothing is split up,
* estimated or counted twice, and contradicting statements are shown side by side with their difference.
*/
final class CaseMoney
{
private function __construct(private Booking $booking) {}
public static function of(Booking $booking): self
{
$booking->loadMissing(['payments', 'amounts']);
return new self($booking);
}
/**
* Who collects the guest's money (us, the portal, nobody for internal cases).
*/
public function collector(): Responsibility
{
return $this->booking->process()->payments();
}
public function total(): ?int
{
return $this->booking->total;
}
public function totalSource(): string
{
return match (true) {
$this->booking->total === null => 'noch nicht bekannt',
($this->booking->quote['source'] ?? null) === 'portal' => 'laut '.($this->booking->processChannel()?->name ?? 'Portal'),
$this->booking->isInternal() => 'vereinbart',
default => 'aus Ihren Preisen berechnet',
};
}
/**
* What the guest still owes us – only when we collect the money.
*/
public function openForUs(): int
{
return $this->collector() === Responsibility::Landlord ? $this->booking->openAmount() : 0;
}
/**
* What the guest still owes the portal according to the portal's statements (informational; the portal collects it).
*/
public function openAtPortal(): ?int
{
if ($this->collector() !== Responsibility::Portal || $this->booking->total === null) {
return null;
}
return max(0, $this->booking->total - $this->booking->paidViaPortal());
}
/**
* Instalments of the guest that the portal still shows as due.
*
* @return Collection<int, CaseAmount>
*/
public function installmentsDue(): Collection
{
return $this->amounts(AmountKind::InstallmentDue);
}
/**
* The price positions as stated, with their sum and whether they add up to the agreed total.
*
* @return array{positions: Collection<int, CaseAmount>, sum: int, difference: ?int}
*/
public function positions(): array
{
$positions = $this->booking->amounts->filter(fn (CaseAmount $amount): bool => $amount->kind->isPricePosition())->values();
$sum = (int) $positions->sum('amount');
return ['positions' => $positions, 'sum' => $sum, 'difference' => $positions->isEmpty() || $this->booking->total === null ? null : $this->booking->total - $sum];
}
/**
* @return Collection<int, CaseAmount>
*/
public function commissions(): Collection
{
return $this->amounts(AmountKind::Commission);
}
/**
* Payout announcements of the portal. Several different values are kept as they are; the difference is shown.
*
* @return array{announcements: Collection<int, CaseAmount>, values: list<int>, difference: int, received: int, outstanding: ?int}
*/
public function payout(): array
{
$announcements = $this->amounts(AmountKind::PayoutAnnounced);
$values = array_values(array_unique($announcements->pluck('amount')->map(fn ($value): int => (int) $value)->all()));
$received = $this->booking->payoutsReceived();
return [
'announcements' => $announcements,
'values' => $values,
'difference' => $values === [] ? 0 : max($values) - min($values),
'received' => $received,
// Only a single, consistent announcement gives an outstanding amount; contradicting ones are left to the person.
'outstanding' => count($values) === 1 ? max(0, $values[0] - $received) : null,
];
}
/**
* Money that really arrived on our account for this case: the guest's own payments (less refunds) and payouts.
*/
public function receivedOnAccount(): int
{
return $this->booking->paidToUs() + $this->booking->payoutsReceived();
}
/**
* @return Collection<int, CaseAmount>
*/
private function amounts(AmountKind $kind): Collection
{
return $this->booking->amounts->filter(fn (CaseAmount $amount): bool => $amount->kind === $kind)->values();
}
}
+1 -1
View File
@@ -209,7 +209,7 @@ private function bestOffers(Collection $offers, array $nightSeasons): array
* @param array<int, int> $extraQuantities
* @return list<QuoteLine>
*/
private function extraLines(Property $property, array $extraQuantities, int $nights): array
public function extraLines(Property $property, array $extraQuantities, int $nights): array
{
$extraQuantities = array_filter($extraQuantities, fn (int $quantity): bool => $quantity > 0);
if ($extraQuantities === []) {
+67
View File
@@ -0,0 +1,67 @@
<?php
namespace App\Pricing;
use App\Enums\QuoteLineType;
use App\Models\Property;
use Carbon\CarbonImmutable;
/**
* The price of an internal case (A6, package 6): the rent agreed for this stay (often 0 for family), the services
* booked with their usual prices, and the tourist tax (Kurabgabe) as a position of its own – the persons liable ×
* nights × the rate the landlord keeps on the property. Exemptions are noted by hand; there is no municipal rule logic.
*/
class PrivateStayPrice
{
public function __construct(private PriceCalculator $calculator) {}
/**
* @param array<int, int> $extras extra id => quantity
*
* @throws QuoteException
*/
public function quote(Property $property, CarbonImmutable $arrival, CarbonImmutable $departure, ?int $guests, array $extras, int $rent, ?int $taxPersons): PriceQuote
{
$nights = (int) $arrival->diffInDays($departure);
$lines = [new QuoteLine(QuoteLineType::Rent, 'Miete (vereinbart)', 1, $rent, $rent)];
array_push($lines, ...$this->calculator->extraLines($property, $extras, $nights));
$tax = self::touristTax($property, $nights, $taxPersons);
if ($tax !== null) {
$lines[] = $tax;
}
return new PriceQuote($arrival, $departure, (int) $guests, $lines, 0, $arrival);
}
/**
* The tourist tax line, or null when no rate is kept or nobody is liable.
*/
public static function touristTax(Property $property, int $nights, ?int $persons): ?QuoteLine
{
$rate = (int) ($property->tourist_tax_rate ?? 0);
if ($rate <= 0 || (int) $persons <= 0 || $nights <= 0) {
return null;
}
$units = (int) $persons * $nights;
return new QuoteLine(QuoteLineType::TouristTax, 'Kurabgabe ('.$persons.' '.((int) $persons === 1 ? 'Person' : 'Personen').' × '.$nights.' Nächte)', $units, $rate, $units * $rate);
}
/**
* The agreed rent of an existing internal case (its rent line), 0 when none.
*
* @param array<string, mixed>|null $quote
*/
public static function rentOf(?array $quote): int
{
foreach ((array) ($quote['lines'] ?? []) as $line) {
if (($line['type'] ?? null) === QuoteLineType::Rent->value) {
return (int) $line['amount'];
}
}
return 0;
}
}
+78 -3
View File
@@ -2,12 +2,16 @@
namespace App\Process;
use App\Actions\EndInternalCase;
use App\Actions\SendBookingDocuments;
use App\Enums\ActivityState;
use App\Enums\BookingStatus;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Enums\ChangeStatus;
use App\Enums\ChannelTaskStatus;
use App\Enums\IntakeKind;
use App\Enums\InternalKind;
use App\Enums\ProcessingMode;
use App\Enums\Responsibility;
use App\Filament\Resources\ChannelTasks\ChannelTaskResource;
@@ -27,6 +31,9 @@ class CaseActivities
/** Activities that are listed on their own in the work list (they are not "the" next step of a case). */
private const LISTED_SEPARATELY = ['channel_block'];
/** Activities that are the next step whatever else is open. */
private const URGENT = ['task_portal_cancel_reported', 'task_portal_change_reported', 'task_portal_cancellation'];
/**
* @return list<Activity>
*/
@@ -41,6 +48,10 @@ public static function for(Booking $booking): array
$later = fn (ActivityState $state): ActivityState => $closed && ! in_array($state, [ActivityState::Done, ActivityState::External], true) ? ActivityState::NotApplicable : $state;
$activities = [];
if ($booking->isInternal()) {
return self::internal($booking, $closed, $later);
}
$activities[] = new Activity('intake', $inquiry ? 'Anfrage eingegangen' : 'Buchung beim Portal eingegangen', ActivityState::Done, $booking->created_at?->format('d.m.Y').' · '.$booking->bookingChannelLabel());
$needsContact = $inquiry || $profile->documents() === Responsibility::Landlord || $profile->guestMessages() === Responsibility::Landlord || $profile->payments() === Responsibility::Landlord;
@@ -110,7 +121,7 @@ public static function for(Booking $booking): array
}
foreach (self::channelTasks($booking) as $task) {
$activities[] = new Activity('channel_block', ($task->action->value === 'block' ? 'In ' : 'Freigeben in ').$task->channel?->name.($task->action->value === 'block' ? ' sperren' : ''), $task->status === ChannelTaskStatus::Open ? ActivityState::Open : ActivityState::Done, $task->period(), url: ChannelTaskResource::getUrl());
$activities[] = new Activity('channel_block', ($task->action->value === 'block' ? 'In ' : 'Freigeben in ').$task->channel?->name.($task->action->value === 'block' ? ' sperren' : ''), $task->status === ChannelTaskStatus::Open ? ActivityState::Open : ActivityState::Done, $task->period().' · '.$task->proofLabel(), url: ChannelTaskResource::getUrl());
}
if ($profile->payments() === Responsibility::Portal) {
@@ -132,7 +143,11 @@ public static function for(Booking $booking): array
}
foreach (BookingTask::query()->where('booking_id', $booking->id)->where('status', BookingTaskStatus::Open)->get() as $task) {
$activities[] = new Activity('task_'.$task->kind->value, $task->kind->getLabel(), ActivityState::Open, $task->due_on ? 'fällig '.$task->due_on->format('d.m.Y') : null, $task->kind->isPayment() ? null : 'end');
$activities[] = self::task($task);
}
foreach ($booking->changes()->where('status', ChangeStatus::Proposed)->get() as $change) {
$activities[] = new Activity('change_proposed', 'Änderungsvorschlag liegt beim Gast', ActivityState::Waiting, $change->summary().($change->expires_at ? ' · bis '.$change->expires_at->format('d.m.Y') : ''));
}
$arrived = $binding && $booking->arrival <= $today;
@@ -152,12 +167,62 @@ public static function for(Booking $booking): array
return $activities;
}
/**
* Own use, private stay or block (A6): only what such a case has – no contract, no reminders, no reviews.
*
* @param callable(ActivityState): ActivityState $later
* @return list<Activity>
*/
private static function internal(Booking $booking, bool $closed, callable $later): array
{
$kind = $booking->internal_kind;
$activities = [new Activity('intake', ($kind?->getLabel() ?? 'Eigene Belegung').' eingetragen', ActivityState::Done, $booking->occasion)];
foreach (self::channelTasks($booking) as $task) {
$activities[] = new Activity('channel_block', ($task->action->value === 'block' ? 'In ' : 'Freigeben in ').$task->channel?->name.($task->action->value === 'block' ? ' sperren' : ''), $task->status === ChannelTaskStatus::Open ? ActivityState::Open : ActivityState::Done, $task->period().' · '.$task->proofLabel(), url: ChannelTaskResource::getUrl());
}
if ($kind !== InternalKind::Block && filled($booking->guest?->email)) {
$activities[] = new Activity('documents', 'Aufenthaltsbestätigung an die Gäste (optional)', $later($booking->confirmation_sent_at !== null ? ActivityState::Done : ActivityState::Later),
$booking->confirmation_sent_at ? 'gesendet am '.$booking->confirmation_sent_at->format('d.m.Y') : 'nur bei Bedarf', $booking->confirmation_sent_at === null && ! $closed ? 'sendDocuments' : null);
}
if ($booking->total !== null && $booking->total > 0) {
$paid = $booking->paidAmount();
$activities[] = new Activity('payment', 'Zahlung (ohne Erinnerungen)', $later($paid >= $booking->total ? ActivityState::Done : ActivityState::Later), Money::format($paid).' von '.Money::format($booking->total).' bezahlt');
}
foreach (BookingTask::query()->where('booking_id', $booking->id)->where('status', BookingTaskStatus::Open)->get() as $task) {
$activities[] = self::task($task);
}
$activities[] = new Activity('stay', $kind === InternalKind::Block ? 'Sperrzeit' : 'Aufenthalt', $closed ? ActivityState::NotApplicable : ($booking->departure <= CarbonImmutable::today() ? ActivityState::Done : ActivityState::Later), $booking->arrival->format('d.m.Y').' – '.$booking->departure->format('d.m.Y'));
return $activities;
}
/**
* An open task of the case and the action that settles it.
*/
private static function task(BookingTask $task): Activity
{
$action = match ($task->kind) {
BookingTaskKind::PortalCancellation, BookingTaskKind::PortalCancellationReported => 'confirmPortalCancellation',
BookingTaskKind::PortalChangeReported => 'change',
BookingTaskKind::RefundCheck => null,
default => $task->kind->isPayment() ? null : 'end',
};
return new Activity('task_'.$task->kind->value, $task->kind->getLabel(), ActivityState::Open, trim(($task->due_on ? 'fällig '.$task->due_on->format('d.m.Y') : '').($task->note ? ' · '.$task->note : ''), ' ·'), $action);
}
/**
* What the landlord should do next on this case, or null when nothing is up to him.
*/
public static function next(Booking $booking): ?Activity
{
foreach (self::for($booking) as $activity) {
$activities = self::for($booking);
// A report of the portal (cancellation, other dates) comes before everything else on the case.
usort($activities, fn (Activity $a, Activity $b): int => (int) in_array($b->key, self::URGENT, true) <=> (int) in_array($a->key, self::URGENT, true));
foreach ($activities as $activity) {
if ($activity->state->needsAction() && ! in_array($activity->key, self::LISTED_SEPARATELY, true)) {
return $activity;
}
@@ -172,6 +237,16 @@ public static function next(Booking $booking): ?Activity
public static function situation(Booking $booking): string
{
$today = CarbonImmutable::today();
if ($booking->isInternal()) {
return implode(' · ', array_filter([
$booking->internal_kind?->getLabel() ?? 'Eigene Belegung',
$booking->occasion,
$booking->status === BookingStatus::Cancelled ? EndInternalCase::label($booking) : ($booking->departure <= $today ? 'beendet am '.$booking->departure->format('d.m.Y') : $booking->arrival->format('d.m.').'–'.$booking->departure->format('d.m.Y')),
]));
}
if ($booking->portal_cancellation_requested_at !== null && $booking->isBinding()) {
return 'Gebucht über '.($booking->processChannel()?->name ?? 'ein Portal').' · Stornierung beim Portal veranlasst – bleibt gebucht, bis sie bestätigt ist';
}
$channel = $booking->processChannel()?->name;
$kind = $booking->intake === IntakeKind::Booking ? 'Gebucht über '.($channel ?? 'ein Portal') : ($channel ? 'Anfrage über '.$channel : ($booking->source === 'website' ? 'Anfrage über die Webseite' : 'Anfrage'));
+4
View File
@@ -23,6 +23,9 @@ final class ProcessProfile
public const CHANNEL = 'channel';
/** Fixed by the case type (A6), not settable. */
public const CASE_TYPE = 'case_type';
/** Settings resolved when they are used instead of being frozen (documents capture their own template). */
public const LIVE = [ProcessSetting::ContractTemplate];
@@ -117,6 +120,7 @@ public static function sourceLabel(string $source): string
self::TENANT => 'Ihre Standardeinstellung',
self::PROPERTY => 'Abweichung der Wohnung',
self::CHANNEL => 'Abweichung des Portals',
self::CASE_TYPE => 'fest für diese Vorgangsart',
'migration' => 'aus dem bisherigen Stand übernommen',
default => 'Grundeinstellung',
};
+8 -1
View File
@@ -49,7 +49,14 @@ public function resolve(Property $property, ?Channel $channel, IntakeKind $intak
}
}
if ($intake !== IntakeKind::Booking) {
if ($intake === IntakeKind::Internal) {
// Own use, private stays and blocks (A6): no rental documents, no payment reminders, no guest mails – fixed by
// the case type, not by a setting.
foreach ([ProcessSetting::Documents, ProcessSetting::Payments, ProcessSetting::GuestMessages] as $setting) {
$values[$setting->value] = Responsibility::Nobody->value;
$sources[$setting->value] = ProcessProfile::CASE_TYPE;
}
} elseif ($intake !== IntakeKind::Booking) {
// A request is answered with our own offer and an internal case is ours anyway: the documents are ours.
$values[ProcessSetting::Documents->value] = Responsibility::Landlord->value;
$sources[ProcessSetting::Documents->value] = ProcessProfile::SYSTEM;
+2 -2
View File
@@ -62,8 +62,8 @@ public static function items(): array
foreach (BlockedPeriod::query()->unclear()->with(['channel', 'property'])->whereDate('ends_on', '>=', today())->orderBy('starts_on')->get() as $occupation) {
$items[] = [
'title' => 'Unbekannte Belegung von '.($occupation->channel?->name ?? 'einem Portal').' – was ist das?',
'detail' => $occupation->starts_on->format('d.m.').'–'.$occupation->ends_on->format('d.m.Y').' · '.$occupation->property?->name,
'title' => 'Belegung von '.($occupation->channel?->name ?? 'einem Portal').' klären',
'detail' => 'Für den Zeitraum '.$occupation->starts_on->format('d.m.').'–'.$occupation->ends_on->format('d.m.Y').' wurde eine Belegung von '.($occupation->channel?->name ?? 'einem Portal').' gemeldet. Bitte klären Sie, um welche Art von Belegung es sich handelt. · '.$occupation->property?->name,
'url' => PortalOccupationResource::getUrl('view', ['record' => $occupation]),
'button' => 'Klären',
'tone' => 'warning',
+3 -7
View File
@@ -2,8 +2,8 @@
namespace App\Tenancy;
use App\Listeners\EnforceMailTestMode;
use App\Models\Tenant;
use App\Support\Settings;
use Illuminate\Mail\MailManager;
use Illuminate\Support\Facades\Mail;
use Throwable;
@@ -146,7 +146,8 @@ public function apply(?Tenant $tenant): void
}
/**
* The mailer sends everything to one address while the landlord is in test mode.
* Rebuilds the mailers so that they use the sender of the current landlord. Where mails go in test operation is
* decided for every single mail by the one gate {@see EnforceMailTestMode}, not here.
*/
public function applyMailRouting(?Tenant $tenant): void
{
@@ -157,11 +158,6 @@ public function applyMailRouting(?Tenant $tenant): void
}
$manager->purge();
$redirect = Settings::mailRedirectFor($tenant);
if (filled($redirect)) {
$manager->alwaysTo($redirect);
}
}
/**
@@ -0,0 +1,62 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
/**
* Package 4 of UMSETZUNGSPLAN_v0.10 (one intake for all channels): every channel says whether recognised portal
* bookings become cases by themselves – off (default for every existing and new channel), observe, or create –, what
* the intake recognised is recorded, and portal tasks record how far a block on the portal is proven. Purely additive.
*/
return new class extends Migration
{
public function up(): void
{
Schema::table('channels', function (Blueprint $table): void {
$table->string('case_intake', 12)->default('off');
});
Schema::create('intake_observations', function (Blueprint $table): void {
$table->id();
$table->foreignId('tenant_id')->nullable()->constrained()->cascadeOnDelete();
$table->foreignId('channel_id')->constrained()->cascadeOnDelete();
$table->foreignId('blocked_period_id')->nullable()->constrained()->nullOnDelete();
$table->foreignId('portal_email_id')->nullable()->constrained()->nullOnDelete();
$table->foreignId('booking_id')->nullable()->constrained()->nullOnDelete();
$table->string('fingerprint', 64);
$table->string('source', 12);
$table->string('mode', 12);
$table->string('outcome', 20);
$table->boolean('applied')->default(false);
$table->string('case_type', 4)->nullable();
$table->date('starts_on')->nullable();
$table->date('ends_on')->nullable();
$table->string('reference', 100)->nullable();
$table->json('reasons')->nullable();
$table->json('missing')->nullable();
$table->timestamp('occurred_at');
$table->timestamps();
$table->unique(['tenant_id', 'fingerprint']);
$table->index(['channel_id', 'occurred_at']);
});
Schema::table('channel_tasks', function (Blueprint $table): void {
$table->string('proof', 12)->nullable();
$table->text('proof_note')->nullable();
$table->timestamp('proof_at')->nullable();
$table->string('proof_by')->nullable();
});
}
public function down(): void
{
Schema::table('channel_tasks', function (Blueprint $table): void {
$table->dropColumn(['proof', 'proof_note', 'proof_at', 'proof_by']);
});
Schema::dropIfExists('intake_observations');
Schema::table('channels', function (Blueprint $table): void {
$table->dropColumn('case_intake');
});
}
};
@@ -0,0 +1,94 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
/**
* Packages 8, 5 and 6 of UMSETZUNGSPLAN_v0.10:
* - external amounts of a case with kind, source and date (case_amounts) and the kind of every payment – a payment of
* the guest to us, one the portal reports as paid to it, a payout of the portal, a refund (package 8);
* - changes of a booking with who asked, why, from when and on which basis, agreed or proposed to the guest (package 5);
* a cancellation records its reason and who entered it; a portal cancellation can wait for the portal's confirmation;
* - own use, private stays and blocks as cases (package 6): their kind, occasion, tourist tax and – for blocks taken over
* from the old block list – the calendar identity the portals already know.
* Purely additive; existing payments count as payments of the guest to us.
*/
return new class extends Migration
{
public function up(): void
{
Schema::table('payments', function (Blueprint $table): void {
$table->string('kind', 20)->default('guest');
$table->string('source', 120)->nullable();
});
Schema::create('case_amounts', function (Blueprint $table): void {
$table->id();
$table->foreignId('tenant_id')->nullable()->constrained()->cascadeOnDelete();
$table->foreignId('booking_id')->constrained()->cascadeOnDelete();
$table->string('kind', 20);
$table->string('label', 150)->nullable();
$table->integer('amount');
$table->string('source', 120)->nullable();
$table->date('stated_on')->nullable();
$table->date('due_on')->nullable();
$table->string('note', 500)->nullable();
$table->string('recorded_by', 120)->nullable();
$table->timestamps();
$table->index(['booking_id', 'kind']);
});
Schema::create('booking_changes', function (Blueprint $table): void {
$table->id();
$table->foreignId('tenant_id')->nullable()->constrained()->cascadeOnDelete();
$table->foreignId('booking_id')->constrained()->cascadeOnDelete();
$table->string('status', 12);
$table->string('requested_by', 12);
$table->string('basis', 20)->nullable();
$table->text('reason')->nullable();
$table->date('effective_on')->nullable();
$table->timestamp('agreed_at')->nullable();
$table->string('agreed_by', 120)->nullable();
$table->json('before');
$table->json('after');
$table->json('consequences')->nullable();
$table->timestamp('expires_at')->nullable();
$table->timestamp('decided_at')->nullable();
$table->string('decision_ip_hash', 64)->nullable();
$table->timestamp('applied_at')->nullable();
$table->timestamp('confirmation_sent_at')->nullable();
$table->string('recorded_by', 120)->nullable();
$table->timestamps();
$table->index(['booking_id', 'status']);
});
Schema::table('cancellations', function (Blueprint $table): void {
$table->text('reason')->nullable();
$table->string('recorded_by', 120)->nullable();
});
Schema::table('bookings', function (Blueprint $table): void {
$table->string('internal_kind', 16)->nullable();
$table->string('occasion', 255)->nullable();
$table->string('export_uid', 120)->nullable();
$table->unsignedTinyInteger('tourist_tax_persons')->nullable();
$table->string('tourist_tax_note', 255)->nullable();
$table->timestamp('portal_cancellation_requested_at')->nullable();
});
Schema::table('properties', function (Blueprint $table): void {
$table->unsignedInteger('tourist_tax_rate')->nullable();
});
}
public function down(): void
{
Schema::table('properties', fn (Blueprint $table) => $table->dropColumn('tourist_tax_rate'));
Schema::table('bookings', fn (Blueprint $table) => $table->dropColumn(['internal_kind', 'occasion', 'export_uid', 'tourist_tax_persons', 'tourist_tax_note', 'portal_cancellation_requested_at']));
Schema::table('cancellations', fn (Blueprint $table) => $table->dropColumn(['reason', 'recorded_by']));
Schema::dropIfExists('booking_changes');
Schema::dropIfExists('case_amounts');
Schema::table('payments', fn (Blueprint $table) => $table->dropColumn(['kind', 'source']));
}
};
+1 -1
View File
@@ -74,7 +74,7 @@ ## 5. Konfiguration auf dem Server (`shared/.env`)
## 5a. E-Mail: Testbetrieb und scharf schalten
- **Betriebsart** in der Verwaltung: **System › Betrieb** (nur Administratoren). Jede Installation beginnt im **Testbetrieb**: alle E-Mails (an Gäste, Vermieterin, Benachrichtigungen) gehen ausschließlich an die dort eingetragene **Testadresse** (ohne Eintrag: `FEWO_NOTIFICATION_EMAIL`), egal was auf der Webseite eingetragen wurde. Ein gelber Hinweis oben in der Verwaltung zeigt das an. Erst „Scharf geschaltet“ liefert an die echten Empfänger.
- **Betriebsart** in der Verwaltung: **System › Betrieb** (nur Administratoren). Jede Installation beginnt im **Testbetrieb**: alle E-Mails (an Gäste, Vermieterin, Benachrichtigungen) gehen ausschließlich an die dort eingetragene **Testadresse** (ohne Eintrag: `FEWO_NOTIFICATION_EMAIL`), egal was auf der Webseite eingetragen wurde. Ein gelber Hinweis oben in der Verwaltung zeigt das an. Erst „Scharf geschaltet“ liefert an die echten Empfänger. Technisch prüft **eine einzige Schranke** jede ausgehende Mail unmittelbar vor dem Versand (`App\Listeners\EnforceMailTestMode`, Ereignis `MessageSending`, für jeden Mailer): Im Testbetrieb ersetzt sie An/Cc/Bcc durch die Testadresse (Original im Kopf `X-Fewo-Testbetrieb-Original`); **ohne jede Testadresse wird gar nichts versendet** (Warnung im Log). Der Modus wird für jede Mail frisch aus der Datenbank gelesen.
- **Adressen der internen Kommunikation** ebenfalls unter System › Betrieb: *Benachrichtigungen an* (mehrere Adressen: neue Anfragen, Angebotsantworten, Fristabläufe, Bewertungen, Portal-Mails/-Aufgaben, Kopie der Zahlungserinnerungen), *Kontakt- und Antwortadresse* (Webseite, Mietvertrag, Antwortadresse der Gäste-Mails), *Absendername/-adresse* (muss zum SMTP-Postfach `MAIL_USERNAME` passen – das Formular warnt). Ohne Eintrag gelten `FEWO_NOTIFICATION_EMAIL`, `FEWO_OWNER_EMAIL`, `MAIL_FROM_*` aus `shared/.env`.
- `FEWO_MAIL_REDIRECT_TO` in `shared/.env` ist eine **harte Überschreibung** für Testserver (gilt auch bei „scharf“); normalerweise leer lassen.
- **Versandweg:** Standard `MAIL_MAILER=log` – dann wird gar nichts zugestellt (auch nicht im Protokoll gespeichert). Für echten Versand in `shared/.env` `MAIL_MAILER=smtp` und `MAIL_PASSWORD=<Passwort des Postfachs info@fewo-stommer.de>` (nur selbst eintragen; Absender und SMTP-Anmeldung: `info@fewo-stommer.de`, Antwortadresse und Benachrichtigungen weiter `FEWO_OWNER_EMAIL`/`FEWO_NOTIFICATION_EMAIL` = fewo@stommer.de), dann `bash scripts/deploy.sh staging artisan optimize`.
-200
View File
@@ -1,200 +0,0 @@
{
"main": {
"id": "e551ceee940ecb6c",
"type": "split",
"children": [
{
"id": "45ad11e6bd426ed7",
"type": "tabs",
"children": [
{
"id": "6f2679f564edc126",
"type": "leaf",
"state": {
"type": "markdown",
"state": {
"file": "00_Prozesslandkarte.md",
"mode": "source",
"source": false
},
"icon": "lucide-file",
"title": "00_Prozesslandkarte"
}
}
]
}
],
"direction": "vertical"
},
"left": {
"id": "677ae3e7a3c51888",
"type": "split",
"children": [
{
"id": "d98321f663785e14",
"type": "tabs",
"children": [
{
"id": "cd2450a4f1ac56b2",
"type": "leaf",
"state": {
"type": "file-explorer",
"state": {
"sortOrder": "alphabetical",
"autoReveal": false,
"showSearch": false,
"searchQuery": ""
},
"icon": "lucide-folder-closed",
"title": "Dateiexplorer"
}
},
{
"id": "5ac14d1839d3ff95",
"type": "leaf",
"state": {
"type": "search",
"state": {
"query": "",
"matchingCase": false,
"explainSearch": false,
"collapseAll": false,
"extraContext": false,
"sortOrder": "alphabetical"
},
"icon": "lucide-search",
"title": "Suchen"
}
},
{
"id": "faa5cd42d8f20e2b",
"type": "leaf",
"state": {
"type": "bookmarks",
"state": {
"showSearch": false,
"searchQuery": ""
},
"icon": "lucide-bookmark",
"title": "Lesezeichen"
}
}
]
}
],
"direction": "horizontal",
"width": 300
},
"right": {
"id": "d7407959975136f3",
"type": "split",
"children": [
{
"id": "5595addba8cae338",
"type": "tabs",
"children": [
{
"id": "7aa1456df3c0e543",
"type": "leaf",
"state": {
"type": "backlink",
"state": {
"file": "00_Prozesslandkarte.md",
"collapseAll": false,
"extraContext": false,
"sortOrder": "alphabetical",
"showSearch": false,
"searchQuery": "",
"backlinkCollapsed": false,
"unlinkedCollapsed": true
},
"icon": "links-coming-in",
"title": "Rückverweise"
}
},
{
"id": "71826ebd06babd87",
"type": "leaf",
"state": {
"type": "outgoing-link",
"state": {
"file": "00_Prozesslandkarte.md",
"linksCollapsed": false,
"unlinkedCollapsed": true
},
"icon": "links-going-out",
"title": "Ausgehende Links"
}
},
{
"id": "94047f11d8cf598a",
"type": "leaf",
"state": {
"type": "tag",
"state": {
"sortOrder": "frequency",
"useHierarchy": true,
"showSearch": false,
"searchQuery": ""
},
"icon": "lucide-tags",
"title": "Tags"
}
},
{
"id": "ca2a154a0256f6d4",
"type": "leaf",
"state": {
"type": "all-properties",
"state": {
"sortOrder": "frequency",
"showSearch": false,
"searchQuery": ""
},
"icon": "lucide-archive",
"title": "Alle Eigenschaften"
}
},
{
"id": "154170f0a686e7f0",
"type": "leaf",
"state": {
"type": "outline",
"state": {
"file": "00_Prozesslandkarte.md",
"followCursor": false,
"showSearch": false,
"searchQuery": ""
},
"icon": "lucide-list",
"title": "Gliederung"
}
}
]
}
],
"direction": "horizontal",
"width": 300,
"collapsed": true
},
"left-ribbon": {
"hiddenItems": {
"switcher:Schnellauswahl öffnen": false,
"graph:Graph-Ansicht öffnen": false,
"canvas:Neuen Canvas erstellen": false,
"daily-notes:Heutige Notiz öffnen": false,
"templates:Vorlage einfügen": false,
"command-palette:Befehlspalette öffnen": false,
"bases:Neue Base erstellen": false
}
},
"active": "6f2679f564edc126",
"lastOpenFiles": [
"00_Prozesslandkarte.md",
"00_Buchungsarchetypen.md",
"00_Portalprofile_und_Vertragsvorlagen.md",
"Buchsungsprozesse/Willkommen.md",
"README.md",
"QUELLENMANIFEST.md"
]
}
@@ -1,168 +0,0 @@
---
id: A00
typ: archetypenkatalog
titel: FewoPortal – Buchungsarchetypen und Verantwortungsübergaben
status: diskussionsentwurf
version: "0.9"
stand: 2026-11-01
prozess: V01
bezugsstand_prozessarchitektur: "0.7"
---
# A00 – Buchungsarchetypen und Verantwortungsübergaben
> **Arbeitsstand für das Fachinterview, nicht abschließend freigegeben.** Grundlage: Betreiberbeschreibung vom 31.10.2026; Übergaben `UEBERGABE-BUCHUNGSPROZESS.md` (30.10.2026) und `crystalline-floating-glacier.md` (31.10.2026); Prozessarchitektur v0.7 und Szenarien R01/R08. **Bestätigte Geschäftsregeln, aktueller Praxisablauf, Annahmen und offene Fragen werden getrennt ausgewiesen.**
## 1. Gemeinsamer Grundsatz
FewoPortal ist das **führende interne Buchungsverwaltungssystem** für mehrere kleine Vermieter mit typischerweise 1–3 Wohnungen je Vermieter. Es gibt **einen generischen Wertschöpfungsprozess V01** mit den Phasen:
1. **P01** Buchungseingang & Verfügbarkeitssicherung
2. **P02** Konditionen & Buchungsverbindlichkeit
3. **P03** Buchungsverwaltung & kaufmännische Abwicklung
4. **P04** Leistungsvorbereitung & Aufenthalt
5. **P05** Abschluss & Nachbereitung
**Archetypen sind Geschäftskonstellationen, keine getrennt zu implementierenden Workflows.** Sie bestimmen die bei Eintritt bekannten Tatsachen, Zuständigkeiten, notwendigen Aktivitäten, Kommunikationswege und Nachweise. Derselbe **Vorgang** und dieselben Fachfunktionen werden verwendet. Die früher diskutierte zusätzlich anzulegende „Buchungsakte“ entfällt als eigenständige fachliche Einheit. Ein Portal kann einzelne Tätigkeiten durchführen; FewoPortal behält den konsolidierten Vorgangsüberblick, ohne fremde Primärnachweise vorzutäuschen.
## 2. Katalog der sechs Archetypen
| ID | Geschäftskonstellation | Zustand beim Eingang | Vertragsunterlagen | Zahlung / Storno | Informationsbedarf |
|---|---|---|---|---|---|
| **A1** | Kompletter Vorgang über eigene Website / FewoPortal | Unverbindliche Anfrage | Verbindliches eigenes Angebot, fristgerechte Annahme, anschließend Vertragsdokumentation | Wir | Eigene Anfrage- und Gastdaten, ggf. ergänzen |
| **A2** | Unverbindliche Anfrage eines Vermittlungsportals, Eingang z. B. über Portalnachricht, E-Mail, Telefon oder erkennbare iCal-Information | Noch keine Buchungsverbindlichkeit | Angebot/Annahme/Vertrag bei uns | Typischerweise wir, profilabhängig | Häufig unvollständig; gezielte Nachforderung |
| **A3** | Externe Direktbuchung mit anschließender vollständiger Abwicklung durch uns | Bereits verbindliche Portalbuchung | Wir versenden Dokumentation der bestehenden Vereinbarung, **keine zweite Annahme** | Wir | Buchung, Portalpreis und Gastdaten übernehmen / ergänzen |
| **A4** | Externe Direktbuchung mit **geteilter Abwicklung** (heutiger FeWo-direkt-Fall) | Bereits verbindliche Portalbuchung | Vertragsdokumentation durch uns ohne zweite Annahme | Zahlung über Portal; tatsächliche Storno-/Mahnverantwortung noch prüfen | Gastdaten, rechtsrelevante Konditionen, Portalstatus, lokale Abgaben |
| **A5** | Externe Direktbuchung mit weitgehend vollständiger Portalabwicklung | Bereits verbindliche Portalbuchung | Durch Portal, soweit tatsächlich vereinbart | Durch Portal, soweit tatsächlich vereinbart | Für Vor-Ort-Betreuung und rechtliche Pflichten benötigte Daten und Status |
| **A6** | Eigenbelegung, private Überlassung (z. B. Familie/Freunde) und sonstige Verfügbarkeitssperre | Interner Belegungsanlass | Je nach Fall Buchungs-/Aufenthaltsbestätigung, interne Reservierungsbestätigung oder kein Dokument | Gegebenenfalls Kurabgabe, Wäsche und andere Zusatzleistungen; bei reiner Sperre keine Gastzahlung | Gäste, Personen und Leistungen **optional**, Sperrgrund immer dokumentieren |
**Historische Einordnung E-012, fortgeschrieben durch E-022:** Der **frühere A6 „Hub-/Partnervermittlung“** wurde abgeschafft und bleibt abgeschafft. Die Kennung **A6 wird neu für interne Belegungs- und Sperrvorgänge** verwendet. Die Weitervermittlungsherkunft ist nur ein optionales kaufmännisches Merkmal. „Manuell/telefonisch“ ist weiterhin ein Eingangskanal und kein eigener Archetyp.
## 3. Gegenüberstellung entlang des generischen Prozesses
| Phase | A1 | A2 | A3 | A4 | A5 | A6 |
|---|---|---|---|---|---|---|
| **P01 Eingang** | Gastanfrage, Verfügbarkeit, ggf. zeitlicher Hold | Portalinformation prüfen, Anfrage qualifizieren, fehlende Daten nachfordern, ggf. Hold | Extern verbindliche Buchung übernehmen, Belegung sichern | Wie A3; Nachricht ggf. nur mit wenigen Gastdaten | Wie A3; lokale Datenversorgung sicherstellen | Internen Anlass erfassen, Zeitraum sichern, Sperrgrund protokollieren |
| **P02 Konditionen / Bindung** | Eigener Preis, bindendes Angebot, fristgerechte Annahme | Nach Ergänzung der Daten grundsätzlich wie A1 | **Verbindlichen Portalpreis übernehmen**; externen Abschluss nachweisen | Gleiches Prinzip; zusätzliche Prüfung der tatsächlich vereinbarten Portalbedingungen | Externen Abschluss/Konditionsstand dokumentieren, kein eigenes Angebot | Optional Gast-/Belegungsbestätigung; kein Mietvertrag für reine Sperre |
| **P03 Abwicklung** | Vertrag, Kalender, Fristen und eigene Zahlungsüberwachung | Grundsätzlich wie A1, Kommunikation ggf. im Portal | Vertragsdokumentation und gesamte weitere Abwicklung durch uns | Vertrag durch uns; Zahlung über Portal; Storno/Mahnung noch abgrenzen | Externe Abwicklung überwachen, soweit für unsere Aufgaben/Haftung erforderlich | Ggf. Gastdaten, Kurabgabe und gebuchte Zusatzleistungen/Zahlungen; reine Sperre ohne Gastabrechnung |
| **P04 Leistung** | Anreise, lokale Pflichten, Aufenthalt, Abreise | Wie A1 | Wie A1 | Wie A1, zuvor Gastinformationen nachfordern | Wie A1, soweit wir vor Ort verantwortlich sind | Private Nutzung oder Wartung; nur notwendige Aktivitäten |
| **P05 Abschluss** | Aufenthalt, Feedback, offene Fälle übergeben | Wie A1 | Wie A1 | Wie A1, ggf. offener Portal-Auszahlungs-/Stornofall | Lokale Erfüllung abschließen, relevante Portal-Ergebnisse erfassen | Nutzung/Arbeit beenden, Belegung freigeben, Folgen nachhalten |
Die Partnerherkunft begründet **keinen zusätzlichen Archetyp**; sie wird nur bei relevantem Einfluss auf die Vermittlerprovision oder notwendige Auswertung erfasst. Phasen können sich zeitlich überlappen; eine bereits extern verbindliche Buchung darf nicht durch offene Stammdaten künstlich unverbindlich werden.
## 4. Gemeinsame Informations- und Übergabegates
| Gate | Einheitlich benötigte Information / Nachweis | Vorgehen bei Lücke |
|---|---|---|
| **G1 – Eingang qualifiziert** | Objekt, Zeitraum, Eingangskanal, Buchungs-/Anfrageart, ggf. externe Referenz; Herkunft, soweit ermittelbar | Unklare Belegung als Klärungsfall; keine ungeprüfte verbindliche Buchung behaupten |
| **G2 – Bindung geklärt** | Entweder **eigenes** fristgerecht angenommenes Angebot oder **externer** Nachweis der Buchungsverbindlichkeit; maßgebliche Konditionen und Preis | Nachweis nachfordern / manuell prüfen; keine zweite Annahme der bereits verbindlichen Portalbuchung |
| **G3 – Abwicklung zugeordnet** | Zuständig für Vertrag, Zahlungsaufforderung, Zahlung, Mahnung, Storno, Rückerstattung, Kommunikation; relevante Fristen und Statusquellen | Zuständigkeit als offen markieren, Klärungsaufgabe erzeugen |
| **G4 – Leistung vorbereitet** | Erforderliche Gästedaten, Kontaktmöglichkeit, Anreise-/Leistungsinformationen, lokale gesetzliche Meldedaten soweit einschlägig | Datenbeschaffung über Portal, Gast oder manuell; Aufenthaltsvorbereitung gezielt verfolgen |
| **G5 – Leistung abgeschlossen** | Aufenthalt/Leistung beendet, Feedbackprozess angestoßen bzw. bearbeitet, offene Nachläufer einer zuständigen Bearbeitung übergeben | Fehlende Übergaben und lokale Folgeaufgaben sichtbar halten |
Pro Gate sind die Zustände **intern erfüllt / extern erfüllt (mit Quelle) / nicht anwendbar / offen** zu unterscheiden. Die **fachliche Bindung** und die **Vollständigkeit der Gastdaten** sind getrennte Dimensionen. Für einzelne Tätigkeiten kann es zusätzliche Feld- oder Fristvoraussetzungen geben.
## 5. A4 – FeWo-direkt als realer Referenzfall (Betreiberangaben)
**Bekannter bzw. beschriebener Ablauf:**
1. Gast bucht unmittelbar über FeWo-direkt; eine verbindliche Buchung entsteht laut Betreiber bereits dort.
2. FeWo-direkt bestätigt die Buchung und fordert Zahlungen (Anzahlung, Restbetrag) über seinen Zahlungsweg an.
3. FewoPortal erhält die Buchungsinformation; der Informationsumfang ist geringer als für die eigene Vertrags- und Aufenthaltsabwicklung erforderlich. Nach jüngster Betreiberangabe sind Name und E-Mail bekannt, die Anschrift fehlt; **tatsächlich übermittelte Felder müssen anhand eines Beispiels verifiziert werden**.
4. FewoPortal ordnet Buchung, Belegung, Portalkonditionen und Referenz zu. **Der vom Gast gebuchte Portalpreis wird nicht durch unsere Kalkulation ersetzt.**
5. Fehlende Gäste-/Vertrags- und ggf. örtliche Meldedaten werden über den verfügbaren Kontaktweg nachgefordert; manueller Fallback bleibt möglich.
6. Wir erstellen und versenden unsere Vertragsdokumentation **ohne erneute formale Annahme**; die Vereinbarung darf dabei nicht stillschweigend um andere Konditionen erweitert werden.
7. FewoPortal steuert Anreise, lokale Betreuung, Aufenthalt, Abreise und Abschluss. Externe Zahlungen/Statusmeldungen werden, soweit verfügbar und erforderlich, referenziert.
**Noch nicht bestätigt / zu prüfen:**
- Welche Vertragsinhalte und Zusatzbedingungen sieht der Gast **vor seiner bindenden Buchung** tatsächlich? Deckt sich das mit dem späteren von uns versandten Vertrag?
- Welche Partei / welcher Zahlungsdienstleister wickelt **Mahnung, Stornierung, Rückerstattung, Nichtzahlung und Schäden** in welcher Konstellation konkret ab?
- Welche Angaben umfasst der **verbindlich vereinbarte Gastpreis**? Werden Plattform-Servicegebühr für Reisende, Vermieterprovision, Steuer/Kurabgabe und Auszahlungsbetrag getrennt ausgewiesen? **Vermieterprovision nicht ohne Grundlage dem Gast zusätzlich berechnen.**
- Wie erhalten wir belastbare Statusinformationen über erfolgte Zahlungen, Stornos und Erstattungen? Wenn das Portal diese nicht maschinenlesbar liefert, ist der manuelle Nachweisweg zu definieren.
- Welche Daten sind für Kurabgabe/Meldepflichten tatsächlich erforderlich, und wann müssen diese vorliegen?
- Welches Ereignis wird beim Eingang einer Portalstornierung/Änderung ausgelöst; wie wird die Belegung aktualisiert und der Betreiber informiert?
**Rechtlicher Prüfvermerk, keine abschließende Bewertung:** Die offiziellen FeWo-direkt-Gastgeberbedingungen beschreiben die Vertragsbeziehung grundsätzlich zwischen Gast und Vermieter sowie Vorgaben zu offenzulegenden Bedingungen und Gebühren. Daraus lässt sich **nicht allein** ableiten, dass der konkrete nachträgliche Versand unseres Vertragsdokuments rechtswidrig oder rechtssicher ist. Zu prüfen sind tatsächlich angezeigte Vertragsbedingungen und konkreter Buchungsablauf. Quellen: [FeWo-direkt Gastgeberbedingungen](https://www.fewo-direkt.de/lp/b/partner-terms-of-use), [FeWo-direkt Gastbedingungen](https://www.fewo-direkt.de/lp/b/terms-of-service).
## 6. Übergreifende Regeln und bewusste Grenzen
- **Einheitliche Akte, einheitliche Konditions- und Vertragszusammenstellung**, keine getrennten Formulare je Kanal.
- Bei **A1/A2** ist unser befristetes Angebot für uns bindend; rechtzeitige Annahme macht die Buchung verbindlich. Bei Fristablauf ohne Annahme endet der Vorgang ohne Buchung, eigene Belegungssperre wird nach Konfliktprüfung freigegeben. **Hold- und Angebotsfrist müssen zusammenpassen** (konkrete Regel noch offen).
- Bei **A3–A5** wird die bestehende externe Verbindlichkeit **nicht** durch eigenen Angebotsversand oder einen erneuten Annahmeklick ersetzt.
- Portalpreise und zugesagte Konditionen sind als **externe Vereinbarung mit Quelle** abzulegen; unsere Vergleichskalkulation darf höchstens erklärend sein.
- Ein iCal-Belegungsereignis **allein** beweist nicht zwingend den Buchungsvertrag. Sichere Klassifikation kann zur automatischen Akte führen; unklare Ereignisse werden nicht still als Buchung interpretiert.
- Fehlende oder widersprüchliche Daten bleiben als **fehlt / unbestätigt / bekannt**, jeweils mit Quelle, sichtbar. Keine erfundenen Werte, keine vermeidbaren Dubletten-Gäste.
- Die Software für kleine Vermieter benötigt **keinen frei skriptbaren Workflow-Designer**; wenige nachvollziehbare Abwicklungsprofile und konfigurierbare Auslöser/Aktivitäten genügen zunächst.
- Automatisierte Entscheidungen sind nachzuvollziehen und bei Fehlzuordnung korrigierbar. Geschäftlich oder rechtlich wirksame Vorgänge sind nicht durch bloßes Löschen „rückgängig“ zu machen.
- Der V01-Prozess kann **regulär abgeschlossen**, **ohne Buchung beendet** oder **storniert** enden. Offene Folgefälle werden kontrolliert übergeben; nicht still verworfen.
## 7. Portalunabhängige Konditions- und Vertragsprofile (Ergänzung 31.10.2026)
**Bestätigte fachliche Regel:** Ein Buchungsportal kann eigene Preise, Rabatte, Stornoregeln und Buchungsbedingungen verwalten. Bei extern verbindlichen Buchungen sind die **tatsächlich vereinbarten Portalkonditionen** maßgeblich. Bei unverbindlichen externen Anfragen kann die anschließende Angebotsgestaltung vollständig bei uns liegen. Der konkrete Datenumfang und die Verfügbarkeit von Nachweisen sind je Portal verschieden.
**Vertragsvorlagen dürfen sich je Vermieter, Wohnung, Portal, Buchungstyp und ggf. tatsächlicher Partnerherkunft unterscheiden.** Die Auswahl erfolgt über das zutreffende Buchungs-/Abwicklungsprofil, **nicht nur über den allgemeinen Portaltyp**; der Vermieter kann sie bei Bedarf in der gemeinsamen Konditionszusammenstellung bewusst ändern. Die gewählte Vorlagenversion, Anlagen und der zugrunde liegende Konditionsstand werden pro Buchung unveränderlich dokumentiert.
Unterscheidung der Dokumentfunktion: **A1/A2** verwenden bindendes eigenes Angebot mit Annahme; **A3/A4** dokumentieren und versenden ggf. die bereits extern verbindliche Vereinbarung **ohne zweite Annahme**; **A5** verlangt eigene Vertragsdokumente nur, soweit dies fachlich/rechtlich tatsächlich erforderlich ist. Nicht belegte oder abweichende Konditionen sind Klärungsfälle, keine automatisch ergänzten Vertragspflichten.
**Zu konfigurierende Kanalmerkmale:** Herkunft verbindlicher Preise/Rabatte/Stornobedingungen, Erkennbarkeit und Nachweise, Zuständigkeiten, erlaubte Dokumente, automatische oder manuelle Datenerfassung und Vertragsversand. Kein hardcodiertes FeWo-direkt-Verhalten.
Siehe [[00_Portalprofile_und_Vertragsvorlagen|00 – Portalprofile und Vertragsvorlagen]] für das schlanke Referenzmodell.
## 8. Bezug zu vorhandenen Dokumenten
- [[00_Prozesslandkarte|Prozesslandkarte]] – V01/V02, fünf Phasen und übergreifende Leitregeln.
- [[G00_Gates_und_Uebergaben|Gates und Übergaben]] – konzeptionelle Gate-Logik.
- [[E00_Entscheidungsprotokoll|Entscheidungsprotokoll]] – bereits bestätigte Entscheidungen.
- [[X00_Sonderprozesse|Sonderprozesse]] – derzeit bekannte Ausnahmefamilien.
- [[R00_Szenarien/R01_Eigene_Webseite|Referenzfall eigene Webseite]] – gesonderter Arbeitsentwurf (sofern dieser bereits ins Repository übernommen wurde).
## 9. Ergänzende A4-Vertragsanalyse (Stand 31.10.2026)
Die vom Betreiber bereitgestellte vierseitige FeWo-direkt-Vertragsvorlage wurde unter [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 – Vertragsvorlage und Prozessanalyse]] gesondert bewertet. Besonders prüfbedürftig sind: Verbindlichkeit vor dem nachträglichen Vertragsversand (§ 5), zuvor einbezogene Konditionen, Preis-/Gebührentrennung (§ 4), Portalstorno gegenüber eigener Stornoklausel (§ 13), Datenbedarf sowie sichere Trennung von Vertragsdokument und Zugangs-/Anreiseinformationen. **Keine Änderung der Betreibervertragsklauseln ohne gesonderte rechtliche und fachliche Freigabe.**
**Status dieses Dokuments:** Fünf Archetypen (A1–A5) nach E-012; Portalprofile und rechtliche Detailfragen bleiben offen. Neben FeWo-direkt (A4) ist Destination Solutions (A3) dokumentierter Praxisfall.
## 10. A4-Praxisnachweis aus FeWo-direkt-Ansichten (31.10.2026)
Für eine konkrete zukünftige Buchung sind **aggregierte Übernachtungsrate, Rabatt, Gebühren/Steuern, Gesamtzahlung des Gastes, Abzug an FeWo-direkt, Auszahlungsvorschau sowie zwei Zahlungsraten und deren Fälligkeits-/Zahlungsstatus** im Vermieterbereich sichtbar. Auch angezeigte Stornobedingungen und der vorgesehene 72-Stunden-Anreiseinformationsversand sind erkennbar. **Nicht nachgewiesen** sind die vollständigen Tagespreis- und Gebührenbestandteile, ein belastbarer allgemeiner Zahlungsexport, die tatsächliche Auszahlung, der vollständige Vertragsinhalt der Gastbestätigung und die vollständigen Gaststammdaten. Zwei Ansichten weisen zudem **unterschiedliche voraussichtliche Vermieterauszahlungen (900,20 € / 894,69 €)** aus, Ursache offen. Details im [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse#7. Nachtrag aus belegten Bildschirmansichten (31.10.2026) – Ist-Zustand, nicht allgemeines Portalverhalten|A4-Vertrags- und Prozessdokument]].
**Portalinvariante:** Verantwortlichkeit für Zahlung oder Kommunikation, Portalstatus und tatsächlicher Erfüllungsnachweis sind getrennt zu verwalten.
## 11. Änderungs- und Stornoereignisse (portalunabhängig)
Ein Storno bzw. eine Buchungsänderung ist ein **Teilprozess auf demselben Vorgang**, kein zusätzlicher Archetyp. Die fachliche Ursache (Gastwunsch, Unmöglichkeit beim Vermieter, Doppelbuchung, Regelverstoß, technischer Fehler), der Initiator, der ausführende Beteiligte und die Abwicklungsverantwortung sind voneinander zu unterscheiden. Anfrage, Bestätigung und tatsächliche Wirksamkeit sind getrennte Ereigniszustände. Kalender, Konditionen, Vertrag und Zahlungen werden erst nach ausreichend belegter Wirksamkeit angepasst. Eine durch den Vermieter verursachte Stornierung darf nicht durch Aufforderung an den Gast als Gaststorno umetikettiert werden. **FeWo-direkt** ist dafür ein dokumentiertes Portalbeispiel (siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 Abschnitt 8]]); andere Portale können abweichende Wege, Daten und Zuständigkeiten haben.
## 12. Destination Solutions als Praxisreferenz A3 (E-012/E-016/E-017/E-018)
- **Verbindlicher Buchungseingang**, vollständige weitere Vertrags-, Gäste-, Zahlungs- und Aufenthaltsabwicklung beim Vermieter; keine zweite Angebotsannahme. Der Vermieter erhält laut Betreiber eine vollständige Buchungsmeldung für seine Abwicklung, **nicht zwingend eine vollständige Einzelpreis- oder Gebührenzerlegung**.
- **Keine im genutzten Zugang funktionierende automatische Kalendersynchronisation**; manuelles Blockieren anderer Portale. Ein Portalbeleg über den Zeitpunkt oder die wirksame Verteilung an Partnerkanäle steht nach Betreibererfahrung nicht zur Verfügung.
- **Vermittlerprovisionen** können nach Vertriebskanal variieren. Sie sind nicht nachträglich vom Gast zu fordern. Ob zusätzlich ein direkter Gast-Aufschlag/Serviceentgelt oder Partner-Endpreisaufschlag existiert, muss beim Anbieter und anhand einer Gastbestätigung geprüft werden.
- **Stornostaffel** vom Betreiber angegeben: ≥60 Tage 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, ≤11 Tage 100 % vom „Mietpreis“; **vorvertragliche Einbeziehung, Berechnungsbasis und rechtliche Wirksamkeit offen**.
Siehe [[R00_Szenarien/R08_Destination_Solutions|R08 Destination Solutions]] und [[O00_Offene_Portalprueffaelle|O00 Offene Portalprüffälle]].
## 13. Portaldaten können unterschiedlich detailliert und zusammengesetzt sein (E-014/E-015)
Bei A2–A5 sind **automatische, manuelle und hybride** Informationen und Tätigkeiten gleichwertig zu modellieren. Pro Buchung sind vollständig aufgeschlüsselte Positionen, **kombinierte Service-/Gebührenpositionen**, bloße Gesamtbeträge sowie nur teilweise verfügbare Zahlungsauszüge möglich. Keine fiktive Zerlegung des Gesamtpreises; unbekannte Gebührenarten, Zahlende/Empfänger und Provisionsanteile bleiben offen. Nachträgliche Zuordnung oder Aufteilung erhält den originalen Portalbetrag und verhindert doppelte Summierung. Fehlende rein interne Kostenanalyse blockiert nicht ohne Weiteres den vertraglichen Aufenthalt. Siehe [[K01_Preisstruktur_und_Abrechnung|K01]].
## 14. Erweiterung v0.9 – A6, einheitlicher Vorgang und pragmatischer Angebotsweg
**Beschluss E-022 bis E-027 (01.11.2026):** A6 umfasst **Eigenbelegung, unentgeltliche oder private Überlassung und sonstige Sperren**, mit konfigurierbarem Grund (z. B. Eigennutzung, Familienbesuch, Reparatur, Reinigung, organisatorische Sperre). Der Vorgang entsteht bei Erfassung des internen Anlasses genauso wie bei A1–A5; eine gesonderte „Buchungsakte anlegen“-Entscheidung entfällt. Die vorhandene Zuordnung extern eingehender Buchungen zum Auslöserportal/Owner wird **als bereits implementiert** vorausgesetzt, nicht neu beauftragt.
- **Optional statt ausnahmslos entgeltfrei:** Familienmitglieder oder Freunde können als Gäste mit Teilnehmerdaten erfasst werden; Kurabgabe, Wäschepakete und andere Zusatzleistungen können anfallen. Eine Mietzahlung ist keine Voraussetzung für diese Funktionen.
- **Gemeinsamer Prozesskern:** Belegung, Kontakte, Aktivitäten, Dokumente, Zahlungen, Ereignishistorie und Storno-/Änderungsfunktion werden soweit benötigt wiederverwendet. Bei einer Wartungssperre dürfen Gäste, Rechnungen und Vertragsdokumente vollständig entfallen. Keine künstliche Durchführung aller P01–P05-Teilschritte.
- **Dokument nach Profil:** Reservierungs-, Buchungs- oder Aufenthaltsbestätigung abhängig von Vermieter, Objekt, Anlass und Vorgangs-/Buchungstyp; reine Sperre kann ohne Versand bleiben. Ein Bestätigungsdokument darf keine nicht vereinbarten Pflichten erzeugen.
- **Abgrenzung zum Hold:** Eine zeitlich begrenzte Reservierung im Rahmen einer A1/A2-Anfrage ist **Teil desselben Vermietungsvorgangs**, kein separater A6.
- **Storno/Änderung:** Verkürzung, Verlängerung, Verschiebung oder Aufhebung einer A6-Belegung nutzt den gleichen technischen Mechanismus, jedoch ohne pauschal mietvertragliche Stornofolgen zu unterstellen.
**A1/A2-Angebotsvereinfachung (E-025/E-026):** Die konfigurierbare **Haltefrist** steuert die eigene Vorreservierung (beispielsweise 0, 24, 48 oder 72 Stunden). Bei Haltefrist größer null kann ein verbindliches, fristgebundenes Angebot mit passender Vorlage erstellt werden, sofern die eigene Sicherung zum Angebot passt. Bei **0** entsteht **keine Reservierung**; versendet wird eine passende Preis-/Verfügbarkeitsauskunft **ohne uneingeschränkt annehmbares Buchungsangebot**. Vor verbindlicher Buchung wird die Verfügbarkeit erneut geprüft und der Abschluss bestätigt. Eine **separate Preisbindefrist** wird **nicht** als MVP-Standard benötigt: Preise werden typischerweise jahresweise gepflegt, Dynamik-/Yield-Management ist nicht vorgesehen. Es bleibt der jeweils vereinbarte, historisierte Buchungspreis maßgeblich.
**Verhältnismäßigkeit (E-027):** Das verbleibende Doppelbuchungsrisiko wird nicht weggemodelliert; Betreiberangabe: zwei Doppelbuchungen in rund zwanzig Jahren. Externe Live-Prüfung wäre vorteilhaft, steht aber nicht überall zur Verfügung. Ein einfacher nachweisbarer Konflikt-/Sperrablauf reicht für den MVP, kein komplexes Risikomodul.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]] · [[R00_Szenarien/R01_Eigene_Webseite|A1 – Eigene Webseite]] · [[R00_Szenarien/R08_Destination_Solutions|A3 – Destination Solutions]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A4 – FeWo-direkt]] · [[00_Portalprofile_und_Vertragsvorlagen|Vertragsprofile]] · [[G00_Gates_und_Uebergaben|Gates]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
@@ -1,125 +0,0 @@
---
id: K00
typ: fachliches-konzept
titel: Portalprofile, Konditionsquellen und Vertragsvorlagen
status: diskussionsentwurf
version: "0.9"
stand: 2026-11-01
prozess: V01
bezugsstand_archetypen: "0.6"
---
# K00 – Portalprofile und Vertragsvorlagen
## 1. Fachliche Leitentscheidung
FewoPortal ist das führende **interne** Verwaltungs- und Dokumentationssystem für die Buchung. **Jeder externe Kanal kann abweichende eigene Regeln und Fähigkeiten haben**: Preis- und Rabattpflege, Stornobedingungen, Vertragsabschluss, Zahlungsabwicklung, Kommunikation sowie Datenlieferung und -nachweis. Das Verhalten eines konkreten Portals (z. B. FeWo-direkt) wird **nicht** als generelle Logik fest in die Software eingebaut.
**Bestätigt:** Für unterschiedliche Portale und Buchungstypen müssen **unterschiedliche, versionierte Vertragsvorlagen/-entwürfe und Anlagen** auswählbar sein. Auch verschiedene Buchungsarten desselben Portals können abweichende Dokumente benötigen.
## 2. Minimaler Portal-/Buchungskontext (fachlich, keine technische Datenmodellvorgabe)
| Eigenschaft | Bedeutung |
|---|---|
| Vermieter und Wohnung | Wer vermietet welches Objekt? |
| Eingangskanal | Eigene Website, Portalnachricht, E-Mail, iCal, Telefon/manuelle Erfassung usw. |
| Portal und ggf. Partnerherkunft | Über welchen Anbieter kam die Buchung, ggf. von welchem Unter-/Partnerportal? |
| Art des Eingangs | Unverbindliche Anfrage oder bereits extern verbindliche Direktbuchung? |
| Verantwortlichkeiten | Wer erstellt/übermittelt den Vertrag, steuert Zahlung, Mahnungen, Storno, Erstattungen, Gastkommunikation? |
| Konditionsquelle | Wo wurden Gastpreis, Rabatte, Zusatzleistungen und Stornoregeln maßgeblich vereinbart? |
| Informationsquelle/-status | Welche Werte/Nachweise sind bekannt, unbestätigt oder fehlen? Wann wurden sie erfasst? |
| Dokumentenprofil | Welche Vorlage, Bedingungen, Anlagen und Versandschritte gelten für diesen Buchungstyp? |
**Zuordnung:** Standard des Vermieters/Objekts → spezifischeres Portalprofil → spezifischer Buchungstyp → ggf. tatsächliche Partnerherkunft. Eine **bewusste Einzelfallauswahl** der Vorlage bleibt möglich und wird dokumentiert. Bei unklarer Zuordnung **kein stillschweigender Vertragssende-Automatismus**.
## 3. Fachliche Dokumentenarten und Auswahl
| Buchungskonstellation | Dokument und Prozess |
|---|---|
| A1 / A2, eigener Angebotsabschluss | Eigenes **bindendes Angebot** mit ausgewählten Vertragsbedingungen/Anlagen. Wirksam angenommene Version wird unverändert nachgewiesen; anschließend Vertragsdokument bzw. Bestätigung aus diesem Stand. |
| A3 / A4, extern bereits verbindlich, Vertragstext/Unterlagen durch uns | **Kanal- und buchungstypspezifische Vertragsdokumentation** der bereits vereinbarten Bedingungen; **keine zweite obligatorische Annahme**. Widersprechende/neue Klauseln nicht still ergänzen. |
| A5, Vertrag/Abwicklung extern | Externen Vertrags- und Konditionsnachweis referenzieren/ablegen, eigene Dokumente nur, wenn erforderlich. Keine doppelte Vertragsbegründung. |
| Optional: Partnerherkunft | **Keine eigenständige Hub-/Vermittlungsvariante.** Nur bei kaufmännischer Relevanz (z. B. unterschiedliche Vermittlerprovision) Herkunft erfassen. **A6 bezeichnet inzwischen interne Belegung und Sperren**, nicht Vermittlung. |
Eine **gemeinsame Konditions-/Vertragszusammenstellung** soll vor dem Versand anzeigen: maßgeblicher Preis, enthaltene/optionale Leistungen, Rabatte, Stornoregel, Gastdaten, gewählte **Vorlage mit Version**, passende **Anlagen**, nachweisbarer Konditionsstand und Dokumentenvorschau. Der Vermieter kann die Auswahl im Rahmen der rechtlich/fachlich zulässigen Regeln korrigieren; keine separaten Portalfomulare.
## 4. Preis- und Konditionsherkunft
- **Eigener Angebotsprozess (A1, typischerweise A2):** FewoPortal berechnet das verbindliche Angebot nach den eigenen für den Vorgang geltenden Regeln.
- **Extern bereits verbindlich (A3–A5):** Der vom Gast beim Abschluss akzeptierte **Portalpreis und Konditionsstand** muss zugrunde gelegt werden. Eigene Berechnung höchstens als Vergleich, niemals als stiller Ersatz.
- Preis, Rabatt, Leistungen, Steuern/Abgaben, Stornoregeln, etwaige Gast-Servicegebühren, Vermieterprovision und Nettoauszahlung **nach tatsächlicher Vertrags- und Gebührenstruktur** unterscheiden; fehlende Angaben als unbekannt markieren.
- Konditionen je Portal können aus API, E-Mail, Portalansicht, Dokumenten oder manueller Erfassung stammen. **Herkunft, Erfassungszeitpunkt und ggf. Nachweis** mitführen.
- Der zum Abschluss gehörende **Konditions-Snapshot** und die tatsächlich generierten Vertragsdokumente bleiben mit Versionsstand/Prüfsumme unverändert nachvollziehbar.
- **Wenn verbindliche Portalbedingungen nicht nachgewiesen werden können, gilt nicht „eigene Standardbedingungen einsetzen“.** Stattdessen Klärungsfall und Prüfung vor Generierung/Versand möglicherweise widersprüchlicher Dokumente.
## 5. Übergabegates, die daraus folgen
- **G2 Verbindlichkeit:** Nachweis *wie* die Buchung verbindlich wurde und welche Konditionen zugrunde liegen; Dokumentenversand ist **nicht** gleich Vertragsschluss.
- **G3 Abwicklung:** Vertragserstellung und -versand, Zahlung, Storno, Mahnung, Rückerstattung und Kommunikationskanal je Buchung einem Akteur zuordnen. Dokumententwurf und Anlagen müssen zum konkreten Profil passen.
- Fehlende Anschrift oder Reisendendaten blockieren nicht rückwirkend die bereits verbindliche Portalbuchung, können aber **eigene Dokumentenerstellung oder lokale Vorbereitung** bis zur Klärung aufhalten.
## 6. Praxisreferenz FeWo-direkt (A4), keine universelle Regel
- Der Vermieter pflegt nach eigener Angabe **Mietpreise im Portal-Belegungskalender** sowie **Rabatte und Stornobedingungen** im Portal.
- Der vierseitige **eigene Mietvertrag ist im FeWo-direkt-Inserat derzeit nicht hinterlegt** und wird später von uns gesendet.
- Der Vermieter kann aktuell nicht verifizieren, welche vollständigen Buchungs-/Vertragsunterlagen der Gast bei Portalabschluss sieht oder erhält. **Unbekannt und rechtlich/operativ zu klären; nicht als nachgewiesene Zustimmung darstellen.**
- Zahlung nach aktuellem Ablauf über FeWo-direkt. Vertragsdokumentation und lokale Gästebetreuung bei uns; Storno-/Mahnverantwortung ist noch genauer zu prüfen.
- Die heutige FeWo-direkt-Vertragsvorlage ist **ein spezielles Dokumentenprofil**, kein globaler Vertragsstandard.
Siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 – Analyse der bisherigen FeWo-direkt-Vertragsvorlage]].
## 7. Bewusste Grenzen / offene Punkte
1. **Keine juristische Freigabe:** Vorlagen und Stornobedingungen werden nicht durch die Software neu formuliert. Prüfung der tatsächlichen Einbeziehung und Wirksamkeit bleibt erforderlich ([§ 305 BGB](https://www.gesetze-im-internet.de/bgb/__305.html)).
2. **Keine Konfigurationshölle:** Es braucht wenige nachvollziehbare Schalter/Zuordnungen und eine manuelle Übersteuerung mit Nachweis, keinen freien Workflow-Designer.
3. **Kein vollständiger Portalpreis-Sync als implizite Voraussetzung:** Daten dürfen je Portal auch kontrolliert manuell übernommen werden, solange Quelle und Status nachvollziehbar sind.
4. **Noch offen:** Welche konkreten Dokumententypen und Anlagen sollen über Vermieter/Objekt/Portal hinweg wiederverwendbar sein, und welche müssen zwingend getrennt bleiben?
**Status:** Portalübergreifende Fachregeln aus dem Interview festgehalten; Auswahlregeln sind ein fachlicher Vorschlag zur späteren Validierung, **keine freigegebene technische Implementierung**.
## 8. Erweiterung v0.2 – Flexible Portal- und Preisfunktionen
**Konfiguration nach tatsächlicher Fähigkeit statt Portalname fest in Programmcode:**
| Merkmal | Konfigurierbare Ausprägungen / Konsequenz |
|---|---|
| Eingang/Belegung | iCal/API/E-Mail/Portalansicht/manuell; zeitverzögert, nicht verfügbar oder unbekannt; manuelle Sperraufgabe zulässig |
| Gast-/Vertragsdaten | vollständig, teilweise, nicht geliefert; ggf. manuell über Gast oder Portal abrufen |
| Vertrag und Preisquelle | eigene verbindliche Angebotsdaten oder extern bestätigter Gastpreis; Gesamtbetrag auch ohne Einzelpreise zulässig |
| Preisdetailtiefe | Einzelpositionen, Sammelpositionen, reiner Gesamtpreis; Gebührentyp oder Empfänger kann ungeklärt bleiben |
| Preisaufschlag/Provision | Vermieterprovision, zusätzliche Gast-Servicegebühr, partnerkanalabhängiger Endpreisaufschlag – getrennt, sofern belegbar; auch kombinierte/unbekannte Position zulassen |
| Zahlungszuständigkeit | Eigener Einzug oder Portal/Paymentanbieter; Ratenstatus, Auszahlungsvorschau und Bankeingang getrennt |
| Stornobedingungen | Portalkonfiguration, beim Vertragsschluss nachweislich vereinbarter Stand, später übermitteltes eigenes Dokument trennen |
| Bearbeitungsmodus | automatisch / manuell / gemischt, nach einzelner Aktivität bzw. verfügbarem Feld; offene Klärungsaufgabe statt erfundene Daten |
| Nachweise | Zeitpunkt der Erfassung, ggf. Screenshot/Buchungsbestätigung, Zeitpunkt und Wirksamkeit einer Kalendersperre soweit nachgewiesen |
**Keine freie Regel-Engine für MVP erforderlich.** Wenige Profilparameter sowie manuelle, nachvollziehbare Bearbeitungsschritte reichen zunächst. Die tatsächliche Informationstiefe kann **von Buchung zu Buchung** variieren, nicht nur pro Portal.
### Konkrete Kanalprofile als gesonderte Referenzfälle
- **FeWo-direkt (A4):** Eigene Miet-/Rabatt-/Stornokonfiguration im Portal; im Vermieterposteingang sind bei einer Buchung einzelne Summen, Zahlungsraten und erwartete Auszahlung ersichtlich, nicht notwendigerweise die Einzelpreiszerlegung. Eigener statischer Mietvertrag bislang nicht im Inserat hinterlegt. Angeblich/öffentlich angebotene Funktionen sind nicht automatisch im konkreten Betreiberkonto vorhanden.
- **Destination Solutions (A3):** Extern bereits verbindliche Buchung; danach vollständige Abwicklung beim Vermieter. **In aktuellem Betreiberzugang keine Kalendersynchronisation**; manuelle Portalsperrung mit begrenzter Nachweisbarkeit. Provision kann nach Vertriebskanal differieren; Gast-Serviceaufschlag, Preisaufschläge und vorvertragliche Anzeige der Stornobedingungen sind noch ungeklärt.
Details: [[K01_Preisstruktur_und_Abrechnung|K01 Preise & Abrechnung]]; [[R00_Szenarien/R08_Destination_Solutions|R08 Destination Solutions]]; [[O00_Offene_Portalprueffaelle|O00 offene Fragen]].
## 9. Erweiterung v0.9 – Vorgangs- und Angebotsabhängige Vorlagen
**Dokumentprofil = Vermieter/Objekt + Kanal/Owner + Vorgangstyp/Archetyp + Angebots-/Verbindlichkeitsart**, gegebenenfalls mit bewusster manueller Auswahl. Das Profil bestimmt nicht allein das Dokument, sondern auch die notwendigen Aufgaben und Versandbedingungen. Die bereits vorhandene automatische Zuordnung externer Buchungen zum **Owner-Portal** wird dabei **genutzt**, nicht neu eingeführt.
| Fall | Geeignete Vorlage | Folgeschritte |
|---|---|---|
| A1/A2, Hold > 0 | **Verbindliches Angebot** mit passender Annahmefrist, AGB/Anlagen und Annahmelink | Reservierung/externen Sperrabgleich, Annahme prüfen, verbindliche Buchung, Bestätigung |
| A1/A2, Hold = 0 | **Preis-/Verfügbarkeitsauskunft unter Vorbehalt**, keine unbedingte Annahmemöglichkeit | Keine Reservierung; bei Buchungswunsch erneut Verfügbarkeit prüfen und explizit bestätigen |
| A3/A4/A5 | **Dokumentation/Bestätigung einer bereits extern verbindlichen Buchung**, soweit eigene Unterlagen benötigt werden | Externen Konditionsstand übernehmen; keine zweite Vertragsannahme |
| A6 privat/Familie/Freunde | **Buchungs-/Aufenthalts- oder Reservierungsbestätigung** mit konkreten Zusatzleistungen und Kosten, falls vereinbart | Gastdaten optional erfassen, Abgaben/Zusatzleistungen prüfen, ggf. Zahlung steuern |
| A6 Wartung/sonstige Sperre | **Interne Bestätigung** oder **kein Dokument** | Kalender sperren, Grund/Aufgaben dokumentieren, bei Ende freigeben |
**Keine eigenständige Preisbindefrist im MVP.** Normalfall ist jahresbezogene Tarifpflege; die Haltefrist ist ein Konfigurationswert für die Belegungssicherung, nicht eine zusätzliche Preisregel. Eine verbindliche Preiszusage ohne verfügbarkeitsgesicherte Annahme muss in der rechtlich geprüften Vorlage klar vom Vertragsschluss unterschieden werden. **Bereits vereinbarte** individuelle Gast-/Portalpreise bleiben als Snapshot unverändert.
**Keine unnötige Konfigurationskomplexität:** Wenige feste Dokumenttypen und transparente Zuordnungen, keine freie Workflow-Engine; Vorlagen und ihre Versionen müssen im Einzelfall überprüfbar sein.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[00_Buchungsarchetypen|Archetypen]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02 Vertragsverbindlichkeit]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Vertragsabwicklung]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]] · [[O00_Offene_Portalprueffaelle|Offene Fragen]]
+29 -120
View File
@@ -2,142 +2,51 @@
id: MAP-00
typ: prozesslandkarte
titel: FewoPortal – Prozesslandkarte
status: arbeitsstand
version: "0.9"
status: fachlicher-arbeitsstand
version: "0.10"
---
# 00 – Prozesslandkarte FewoPortal v0.9
# Prozesslandkarte FewoPortal
**Status:** gemeinsamer Arbeitsstand; übergreifendes Modell, nicht vollständig freigegeben.
**Stand:** 01.11.2026
## Produkt und Wertschöpfung
## A. Führungsprinzip
FewoPortal ist eine mandantenfähige Plattform für kleine Ferienwohnungsvermieter (typisch **eine bis drei Wohnungen pro Vermieter**). Es unterstützt die eigene Website und externe Buchungskanäle; es ist **kein Ferienwohnungsmarktplatz** und vorerst kein umfangreiches Hotel-, Agentur-, Personal- oder Objektmanagementsystem. Ziel sind Gästegewinnung und eine möglichst einfache, verlässliche und weitgehend automatisierte Buchungs- und Aufenthaltsabwicklung.
FewoPortal ist das **führende Verwaltungssystem für den gesamten Buchungsvorgang**: einheitlicher Vorgang, Prozesszustände, Fristen, Aufgaben, Dokumente, Kontakte, Kalender und Ereignisse. Ein angebundenes Portal kann fachliche Schritte übernehmen. FewoPortal hält **Ergebnis, Herkunft/Nachweis, Zuständigkeit und erforderliche Folgeaktivitäten** fest. Für externe Tatsachen (z. B. Portalzahlungen) bleibt das Portal die primäre Informationsquelle.
| Wertschöpfungsprozess | Zweck |
|---|---|
| **V01 – Buchung und Aufenthalt** | Geschäftsfall vom ersten relevanten Anlass bis zum fachlichen Abschluss steuern; **ein gemeinsamer Vorgang** mit bedarfsgerechtem Ablauf |
| **V02 – Vermarktung, Gästegewinnung und Gästebindung** | Website, Portale, Social Media, Print, Interessenten, Wiederbuchung, CRM/Loyalty; kann V01 auslösen und nach V01 fortgeführt werden; derzeit nur als fachlicher Rahmen |
Es gibt **einen generischen Buchungsprozess**; je Portal, Eingangsart und ggf. Herkunft sind Auslöser, Aktivitäten, Verantwortlichkeiten, Datenbeschaffung und Ausgänge konfigurierbar. **Keine parallelen Buchungsprozesse und Verwaltungsoberflächen.**
## V01 – Hauptwertschöpfungsprozess
Ein extern ausgeführter Schritt bedeutet nicht automatisch „übersprungen“; zu unterscheiden sind **intern erledigt / extern erfüllt / fachlich nicht anwendbar / offen bzw. Klärungsbedarf**.
| Phase | Kernergebnis |
|---|---|
| **P01 – Eingang und Verfügbarkeit** | Anlass, Art, Quelle, Unterkunft und Zeitraum erkannt; Belegung/Hold/Sperren und Klärungen bearbeitet |
| **P02 – Konditionen und Verbindlichkeit** | Eigene Verbindlichkeit begründet oder externe Verbindlichkeit übernommen; ggf. geeignete Bestätigung; Konditionsstand bekannt bzw. Lücken gekennzeichnet |
| **P03 – Verwaltung und kaufmännische Abwicklung** | Dokumente, Gäste, Leistungen, Zahlungen, Provisionen, Fristen und Zuständigkeiten sachgerecht bearbeitet |
| **P04 – Vorbereitung und Aufenthalt** | Lokale Leistungen, notwendige Daten, Anreise und Aufenthalt bzw. interne Nutzung/Arbeiten unterstützt |
| **P05 – Abschluss und Nachbereitung** | Erfüllung oder alternative Beendigung dokumentiert; offene Folgeangelegenheiten zugewiesen |
## A1. Produktmandat und bewusste Abgrenzung (Betreiberentscheidungen E-007 bis E-009)
**Diese Phasen sind eine fachliche Hierarchie, keine fünf starren Bildschirmseiten oder zwingenden Wartezustände.** Schritte können entfallen, parallel oder zu einem späteren Zeitpunkt ausgeführt werden; nicht anwendbare Aktivitäten werden nicht künstlich erzwungen.
- **Heute:** Eigene Internetpräsenz als einheitlicher Einstiegspunkt für die Ferienwohnungen eines Vermieters; mehrere getrennte Vermieter/Mandanten möglich. Typischer Zielkunde vermietet **eine bis maximal etwa drei Wohnungen**.
- **Geschäftsziel:** Über eigene Website und externe Kanäle Gäste gewinnen, Buchungen abschließen und deren Abwicklung mit möglichst wenig Betreiberaufwand zentralisieren und automatisieren. **Kein eigener Marktplatz.**
- **Produktschwerpunkt:** V01 Buchung/Aufenthalt und V02 Vermarktung, Gästegewinnung und Gästebindung. Dazu zählen auch Social Media, Print, externe Portale, Stammkundenmanagement und Loyalty als fachlich vorgesehene Ausbaubereiche.
- **Keine Überdehnung:** Buchungsbezogene Reinigung, Schlüsselübergabe und lokale Leistungen werden möglichst einfach **innerhalb desselben Vorgangs** angestoßen und nachvollzogen. Umfangreiche Objektverwaltung, Personal-/Tourenplanung und Agentur-/Zimmervermittlungsfunktionen sind **nicht Teil der aktuellen Schwerpunktsetzung**.
- **Erweiterbarkeit ohne Vorabkomplexität:** Eine spätere SaaS-Erweiterung für größere Vermittler bleibt möglich, bestimmt aber **nicht** heutige Masken, Prozessvarianten oder Modulzuschnitte. Fachliche Prozessfamilien sind **keine automatische Vorgabe** für eigenständige Softwaremodule.
- **Bedienprinzip:** Der Vermieter sieht wenige, konkrete Aufgaben im Buchungskontext statt die interne Prozessarchitektur. Fachliche Vollständigkeit im Hintergrund darf nicht zu einer komplexen Bedienoberfläche führen.
## Einheitlicher Vorgang
## B. Wertschöpfungsprozesse
Jeder qualifizierte geschäftliche Anlass führt zu einem **Vorgang**, ohne separate Entscheidung „Buchungsakte anlegen“: eigene bzw. vermittelte Anfrage, bereits verbindliche externe Buchung oder interne Eigenbelegung/private Überlassung/Sperre. Ein unklarer technischer Import ist bis zur Klärung noch **kein nachgewiesener Vertrag**. Doppelte Portalmeldungen und Spiegelungen desselben Sachverhalts dürfen nicht zu zusätzlichen unabhängigen Vorgängen führen. Eine „Buchungsakte“ ist allenfalls eine Ansicht, keine zusätzlich zu eröffnende fachliche Einheit.
| ID | Wertschöpfungsprozess | Phasen / Zweck |
|---|---|---|
| **V01** | **Buchung und Aufenthalt** | P01–P05, einschließlich Feedback |
| **V02** | **Vermarktung, Gästegewinnung und Gästebindung** | Eigenständiger, V01 vor- und nachgelagerter Wertschöpfungsprozess: Multichannel-Marketing, Interessentengewinnung, CRM, Wiederbuchung, Loyalty (E-001, E-008) |
**Vorgang ≠ Belegung.** Ein Vorgang dokumentiert Anlass, Beteiligte, Zustand, Aufgaben, Leistungen, Konditionen, Dokumente, Zahlungen und Ereignisse. Eine Belegung/Hold/Sperre beschreibt die zeitliche Verfügbarkeit des Objekts. Ein Vorgang kann Belegungswirkungen auslösen; importierte Spiegelungen sind keine eigenen Vertragsvorgänge.
### V01 – Generischer Hauptwertschöpfungsprozess
Die bestehende **Owner-/Ursprungskanal-Zuordnung** ist eine vorhandene Funktion. Der technische Eingang (z. B. E-Mail/iCal), Ursprungskanal und ggf. provisionsrelevante Partnerherkunft sind begrifflich zu unterscheiden. Herkunftsketten sind **kein eigener Archetyp**.
| Phase | Arbeitsbezeichnung | Fachliches Kernergebnis |
|---|---|---|
| **P01** | Buchungseingang & Verfügbarkeitssicherung | Anfrage oder verbindliche externe Buchung erkannt; Belegung/Hold korrekt vermerkt; fehlende Eingangsdaten als Aufgaben sichtbar |
| **P02** | Konditionen & Buchungsverbindlichkeit | Verbindlichkeit durch fristgerechte Annahme des **von uns bindenden Angebots** oder Nachweis einer schon verbindlichen Portalbuchung; gültige Konditionen revisionsfähig festgehalten |
| **P03** | Buchungsverwaltung & kaufmännische Abwicklung | Vertragsdokumente, Zahlungszuständigkeit, Fristen und Verwaltungsaufgaben gesteuert, auch bei extern verantworteten Aktivitäten |
| **P04** | Leistungsvorbereitung & Aufenthalt | Informationen und lokale Leistungen bereitgestellt; Anreise, Aufenthalt, Abreise betreut |
| **P05** | Abschluss & Nachbereitung | Buchungs- und Leistungserbringung fachlich abgeschlossen; offene, danach eigenständig zu bearbeitende Fälle kontrolliert an Folgeprozesse übergeben; Feedback und objektbezogene Folgeaufgaben; zulässige Übergabe an V02 |
## Führungs- und Verantwortungsprinzip
### V02 – Vermarktung, Gästegewinnung und Gästebindung (fachlich vorgesehen, Details später)
FewoPortal ist das führende **interne** Verwaltungs- und Arbeitsinstrument. Ein externes Portal kann den Vertrag abschließen, Geld einziehen, Nachrichten oder Stornierungen bearbeiten. Im Vorgang werden deshalb **tatsächlicher Sachverhalt, Quelle, fachliche Zuständigkeit, Nachweis und erforderliche eigene Folgehandlung** festgehalten. Externe Verantwortung bedeutet nicht, dass eine Leistung nachweislich bereits erbracht wurde.
- **Vor der Buchung:** Reichweite und Interessenten über eigene Website, Social Media, Print und externe Portale gewinnen; Herkunft einer Anfrage/Buchung möglichst nachvollziehbar halten. Externe Portale können dabei **Marketing- und Buchungskanal** zugleich sein.
- **Nach der Buchung:** Bestehende Gäste für Wiederbuchung und Loyalty berücksichtigen; zulässige CRM-/Marketingaktivitäten und passende Angebote ermöglichen. Loyalty-Merkmale können als Eingabe für die Konditionsbildung in P02 dienen.
- **Schnittstelle:** V02 kann Nachfrage/Anfragen an V01 übergeben; P05 bleibt für **Dank, Feedback und Bewertungsabwicklung** zuständig und kann bei zulässiger Grundlage Ereignisse an V02 melden.
- **Priorisierung:** Fachlich vorsehen, aber jetzt nicht die detaillierte Kampagnenverwaltung oder einen eigenständigen Marketing-Funktionskomplex implementieren.
Unvollständige oder nicht automatisch abrufbare Daten sind normale Fälle: gezielte manuelle Beschaffung, Klärung und späterer Abgleich sind zulässig. **Unbekannt ist nicht null**. Eine fehlende Provisionsaufschlüsselung darf beispielsweise nicht die Anreise blockieren, wenn sie dafür nicht benötigt wird.
**Die Phasen sind logische Gruppierungen, keine zwingend exklusiven Zeitfenster.** Zahlungen/Fristen laufen u. U. über P03 hinaus, Datenbeschaffung kann nach der verbindlichen Buchung weiterlaufen. Kern-Gates beschreiben nachweisbare Zustände; Detail-Gates beschreiben Voraussetzungen für konkrete Tätigkeiten.
## Prozessausgänge und Grenzen
## C. Eingangspfade und Verbindlichkeit (fachlich vom Betreiber präzisiert)
V01 endet – abhängig vom Fall – **regulär nach Aufenthalt/Nutzung**, **ohne verbindliche Buchung** (z. B. Angebotsablauf), **durch wirksame Stornierung** oder bei A6 durch planmäßige bzw. vorzeitige Beendigung einer Sperre. Offene Forderungen, Schäden oder Differenzen können danach als zugewiesene Folgeangelegenheiten weiterlaufen; sie werden nicht still gelöscht. Die genaue Pflichtprüfliste für den Abschluss ist fachlich noch zu konkretisieren.
| Pfad | Entstehung der Verbindlichkeit | Preis/Konditionen | Vertrag und Verwaltung |
|---|---|---|---|
| Eigene Website / manuell / unverbindliche Portalanfrage | Wir geben **ein für uns verbindliches, befristetes Angebot** ab; die rechtzeitige Annahme durch den Gast führt zum Vertrag | Eigene Preisermittlung mit Sonderleistungen, Saison/Rabatten/Loyalty; versionierter Konditionsstand | FewoPortal erstellt Angebot, Annahmenachweis und Vertragsunterlagen; danach eigene Verwaltung |
| Verbindliche Portal-Direktbuchung, Vertrag durch uns | **Bereits beim Portal verbindlich**; **keine zweite Annahme** bei uns | **Im Portal vereinbarter Preis zwingend als Buchungspreis übernehmen**; unsere Berechnung darf ihn nicht still ersetzen | Wir erzeugen/übermitteln das Dokument zur bestehenden Buchung; etwaige Zusatzpflichten nicht nachträglich einseitig hinzufügen; Zahlungszuständigkeit nach Profil |
| Verbindliche Portal-Direktbuchung, vollständige Abwicklung durch Portal | **Bereits beim Portal verbindlich** | Externe Konditionen als maßgeblich kennzeichnen, soweit für lokale Ausführung nötig | Portal verantwortet z. B. Vertrag, Zahlung, Mahnung, Storno; FewoPortal verwaltet notwendige Gästeinfos, lokale Betreuung, Abgaben und relevante externe Status/Ereignisse |
Support- und Sonderprozessfamilien sind **fachliche Fähigkeiten**, keine Verpflichtung, eigenständige Softwaremodule zu bauen. Buchungsbezogene Objektaufgaben bleiben möglichst im Vorgang integriert; die Bedienoberfläche soll wenige klare Aufgaben zeigen.
Bei **eigenem Angebot**: Konfigurierbare Annahmefrist; wir bleiben im beschriebenen Zeitraum gebunden. Rechtzeitige Annahme beendet das Angebot mit dem Ergebnis „verbindlich gebucht“; ohne rechtzeitige Annahme erlischt das Angebot und die **eigene** Vorreservierung wird nur nach Konfliktprüfung freigegeben. Ein extern bereits bestätigter Aufenthalt wird dadurch nicht gelöscht. Angebote und Nachweise bleiben historisch erhalten.
Vertraglicher Nachweis und ggf. PDF-Übermittlung dürfen rechtliche Verbindlichkeit **nicht neu definieren**: Eine bereits verbindliche Portalbuchung bleibt verbindlich; ihr Preis und ihre maßgeblichen Bedingungen müssen gewahrt bleiben. Die rechtlichen Anforderungen der jeweiligen Konstellation sind separat zu prüfen.
## D. Wiederverwendbare Supportprozessfamilien (vorläufig)
Diese Familien dienen der **fachlichen Vollständigkeit**. Sie werden in der aktuellen kleinen Vermieterplattform in erster Linie als **integrierte Funktionen und Aktivitäten** von V01/V02 realisiert. Eine eigenständige Verwaltungsoberfläche ist weder aus dem Namen noch aus der Dokumentation abzuleiten. Buchungsunabhängige Objekt- und Agenturverwaltung sind nachrangige mögliche Erweiterungen.
- S01: Portal-, Kanal- und Integrationsmanagement
- S02: Verfügbarkeit, Belegung, Kalenderabgleich und Synchronisationskontrolle
- S03: Gast-, Objekt- und weitere Stammdaten
- S04: Preis-, Leistungs-, Rabatt- und Konditionsmanagement
- S05: Dokumenten-, Vorlagen- und Nachweismanagement
- S06: Kommunikation, Aufgaben, Fristen und Eskalation
- S07: Zahlungen, Forderungen und Portalstatus-Abgleich
- S08: Buchungsbezogene Objekt- und Dienstleisterleistungen (Schlüssel, Reinigung, Vorbereitung, Reparatur) **integriert in P04/P05**; umfangreiches eigenständiges Objektmanagement derzeit **nicht priorisiert**
- S09: Mandanten, Berechtigungen, Compliance und Sicherheit
## E. Wiederverwendbare Sonderprozessfamilien (vorläufig)
- X01: Angebotsänderung und Neuangebot
- X02: Vertragsänderung, Umbuchung und Zusatzleistungen nach Vertragsschluss
- X03: Ablehnung, Angebotsablauf, Holdablauf und Freigabe
- X04: Stornierung/Rücktritt durch Gast, Portal oder Vermieter
- X05: Zahlungsverzug, Mahnung, Erstattung, Streitfall
- X06: Widersprüchliche/unvollständige Daten und Dubletten
- X07: Doppelbuchung, Kalenderkonflikt, Portal-/Importfehler
- X08: No-show, vorzeitige Abreise, Verlängerung
- X09: Reklamation, Schaden, Kaution und Nachforderung
Ein Sonderprozess kann mehrere Phasen betreffen und verwendet denselben Vorgang und dieselbe Ereignishistorie. **Nach abgeschlossenem Buchungs- und Leistungsprozess** können noch offene Ansprüche oder Konflikte als eigenständig zu bearbeitende Folgeprozesse weitergeführt werden; die Referenz auf die ursprüngliche Buchung und der Übergabenachweis bleiben erhalten (E-010).
**Alternative fachliche Endergebnisse V01 (E-011):** Ein regulär erfüllter Aufenthalt, eine ohne Buchung beendete Anbahnung (z. B. Angebotsablauf oder Ablehnung) und die Stornierung nach entstandener Verbindlichkeit sind unterschiedliche Ergebnisse **desselben** generischen Prozesses. Eine reguläre Leistungserbringung durchläuft typischerweise P05; ein früher Abbruch muss nicht künstlich P03–P05 durchlaufen. Auslösende Ereignisse, Nachweise, ggf. Belegungsfreigabe und verbleibende Folgepflichten werden nachvollziehbar dokumentiert. Weitere Endergebnisse sowie exakte Übergangsbedingungen sind offen.
## F. Zentrale Gate-Philosophie
**P05-Abschluss-/Übergabegate (E-010):** Abschluss der Buchungs- und Leistungserbringung ist vom Ende nachlaufender Forderungs-, Schadens- oder Streitfälle zu unterscheiden. Offene Fälle werden mit Kontext, Verantwortlichkeit und Referenz zur Buchung an den jeweils zuständigen Folgeprozess übergeben. Die endgültigen Pflichtkriterien und Zustände werden in P05 spezifiziert.
Gates dokumentieren **Trigger, erwartetes Ergebnis, erforderliche Daten, Herkunft/Nachweis, zuständige Stelle, Ergebnisstatus, Folgeschritt**. Pflichtinformationen sind **aktivitätsbezogen**, nicht für alle Portale pauschal identisch. Fehlende Adressdaten dürfen eine durch Portalnachweis verbindliche Buchung nicht entwerten; sie blockieren nur Tätigkeiten, für die sie wirklich erforderlich sind.
## G. Noch zu entscheiden
1. **Detailkriterien für den fachlichen Abschluss von V01:** Welche Leistungen, Informationen und Übergaben müssen konkret abgeschlossen sein? Die Grundentscheidung ist getroffen: Nachlaufende Forderungen/Schäden blockieren nicht allein den Abschluss der Buchungs- und Leistungserbringung, wenn sie nachvollziehbar an einen verantwortlichen Folgeprozess übergeben wurden (E-010).
2. Detailschnitt der buchungsbezogenen Objektaufgaben zu P04/P05; **keine Entscheidung für ein eigenständiges Objektmanagement-Modul**.
3. Genauer Status- und Gate-Katalog, **einschließlich alternativer Prozessausgänge nach E-011**, Synchronisationssicherheit und externer Stornoereignisse.
4. Abgrenzung P03/P04; Relevanz und Nachweisbarkeit der lokalen Prozesse.
5. Pro Kanal tatsächlicher Verbindlichkeitsnachweis, Datenlage und Portalbestimmungen.
Die detaillierte Umsetzung erfolgt erst nach Abstimmung der Prozesslandkarte.
## H. Konkretisierung v0.7: Portalneutralität, Informationslücken und Verantwortlichkeit
**A1–A5 (E-012, historischer Stand):** Buchungs- und Abwicklungsverantwortung klassifizieren die Vermietungsarchetypen. Der **damalige A6 für Partnervermittlung** entfiel; Herkunft/Partnervertrieb bleibt lediglich eine kaufmännische Metainformation. **Aktuelle Fortschreibung E-022:** Zusätzlich gilt **A6 = Eigenbelegung, private Überlassung und sonstige Sperren**, im gemeinsamen Vorgang mit bedarfsabhängig verkürzten Aktivitäten. Referenzfälle: **FeWo-direkt A4**, **Destination Solutions A3**. Der identische V01-Prozess durchläuft dieselben fachlichen Phasen/Gates, Aktivitäten können je Profil extern/intern oder manuell/automatisch erfolgen.
**Fünf unabhängige Dimensionen je Buchung:** (1) rechtlicher Bindungs-/Konditionsnachweis, (2) operative Zuständigkeit, (3) technische Datenquelle/Übermittlungsweg und Verfügbarkeit, (4) preisliche Detailtiefe bzw. Zuordnungsgrad, (5) tatsächliche Nachweisqualität. Aus „Portal zuständig“ folgt weder „erledigt“ noch „nachgewiesen“.
**Kaufmännischer Grundsatz (E-014/E-015):** Das Portal kann Einzelposten, Teilaggregationen, Gesamtpreise, unbekannte Gebührenmischungen oder widersprüchliche Auszahlungsansichten liefern. FewoPortal darf den verbindlichen Gastpreis bei externer Buchung nicht durch Eigenkalkulation ersetzen, keine unbekannten Einzelposten erfinden und keine Vermittlerprovision ohne Vereinbarung dem Gast nachberechnen. Eine manuelle Klärung kann ergänzen; ursprüngliche Rohdaten bleiben erhalten.
**Verfügbarkeit (E-018):** Keine generelle Aussage, dass alle Vertriebskanäle synchron oder endgültig gesperrt sind. Manuell oder zeitversetzt übertragenes Blockieren ist kein Nachweis partnernetzweiter Wirksamkeit. Sofort bestätigte externe Doppelbuchungen bleiben wirksame **Konfliktfälle**, nicht automatisch ablehnbare Anfragen. Eine vorgeschlagene Livefreigabe/10-Minuten-Karenz ist derzeit nur **optionales Zukunfts-/Integrationskonzept**, kein Ist-Ablauf.
**Nachträgliche Ereignisse (E-019):** Änderungsanfrage, bestätigte Änderung, Stornierungswunsch und wirksame Stornierung unterscheiden. Ursache, Durchführender, vertragliche Folgen, Belegung und Geldflüsse getrennt dokumentieren.
**Zu vertiefen:** [[K01_Preisstruktur_und_Abrechnung|K01 Preis- und Abrechnungsmodell]], [[X01_Belegungskonflikte_und_Sperrnachweise|X01 Belegungskonflikt- und Sperrnachweise]], [[O00_Offene_Portalprueffaelle|O00 offene Portalfragen]].
## I. Fachliche Konsolidierung 01.11.2026: Vorgang und A6 (E-022–E-028)
**V01** ist der gemeinsame fachliche Wertschöpfungs-/Bearbeitungsrahmen für **A1–A6**. **Vorgang** bedeutet die durchgehende Bearbeitung ab qualifiziertem Anlass – Anfrage, bindende externe Buchung oder interner Belegungs-/Sperrwunsch – bis zum passenden Ende. Ein zusätzlicher Schritt „Buchungsakte anlegen“ entfällt. Die bereits implementierte Owner-Zuordnung bei externen Buchungen bleibt bestehen. **Belegung** (Objekt, Zeitraum, Sperr-/Reservierungswirkung) ist mit dem Vorgang verknüpft, aber nicht gleichbedeutend mit dem ganzen Vorgang.
**A6** bündelt Eigenbelegung, Familien-/Freundesaufenthalt und Wartungs-/sonstige Sperren. Es nutzt je nach konkretem Anlass die allgemeinen Aktivitäten von P01–P05; nicht benötigte Vertrags-, Gästekommunikations-, Zahlungs- oder Aufenthaltsaktivitäten sind **nicht anwendbar**. Private Überlassung kann dagegen Gastdaten, Kurabgabe, Wäschepakete, Zahlung und eine passende Bestätigung benötigen. Ein Hold für ein A1/A2-Angebot bleibt **Teil dieses Vermietungsvorgangs**, kein zweiter A6.
**Angebot (A1/A2):** Haltefrist pro Anfragekanal konfigurierbar. Hold > 0 ermöglicht bei passender Sicherung und Frist ein bindendes Angebot; Hold = 0 führt zu einer Preis-/Verfügbarkeitsauskunft ohne reservierte Wohnung, mit erneuter Prüfung vor verbindlicher Bestätigung. Die Auswahl von **Dokumentenvorlage, Versand und Folgeaktivitäten erfolgt automatisch nach Kanal und Vorgangstyp**; eine separate Preisbindefrist/Yield-Management ist kein MVP-Standard. Jährliche Tarifpflege und tatsächlicher vertraglicher Buchungspreis bleiben voneinander getrennt.
**Implementierungsgrenze:** Die derzeitige Konzeption ist keine vollständige Coding-Freigabe; zuerst Bestands-/Gap-Analyse gegen die vorhandene Anwendung, anschließend begrenzte Arbeitsaufträge.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01 Buchungseingang]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02 Konditionen und Bindung]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Verwaltung und Abwicklung]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04 Aufenthalt]] · [[P05/P05_Abschluss_und_Nachbereitung|P05 Abschluss]] · [[G00_Gates_und_Uebergaben|Gates]] · [[S00_Supportprozesse|Supportprozesse]] · [[X00_Sonderprozesse|Sonderprozesse]] · [[00_Buchungsarchetypen|Archetypen]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
**Vertiefung:** [A1–A6](01_Buchungsarchetypen.md) · [P01](V01_Buchung_und_Aufenthalt/P01_Buchungseingang_und_Verfuegbarkeit.md) · [Sonderprozesse](Querschnitt/Sonder_und_Supportprozesse.md).
@@ -0,0 +1,38 @@
---
id: A00
typ: archetypenkatalog
titel: Buchungsarchetypen A1–A6
status: fachlicher-arbeitsstand
version: "0.10"
---
# Buchungsarchetypen A1–A6
**Archetyp = Geschäftskonstellation**, kein eigenes System und kein separater Workflow. Maßgeblich sind die **tatsächliche Eingangsart und Abwicklungsverantwortung**, nicht nur der Name des Kanals. Ein Kanal kann sowohl unverbindliche Anfragen als auch verbindliche Buchungen liefern. Die Abwicklung richtet sich nach dem für den Vorgang gültigen Profil.
| Typ | Geschäftsfall | Vertragsverbindlichkeit bei Eingang | Typische weitere Abwicklung |
|---|---|---|---|
| **A1** | Eigene Website / eigener vollständiger Buchungsweg | Zunächst Anfrage | Eigene Auskunft bzw. bindendes Angebot, Annahme, Vertrag, Zahlung, Aufenthalt |
| **A2** | Unverbindliche Anfrage eines externen Vermittlers | Noch nicht verbindlich | Fehlende Daten ergänzen; eigener Angebots- und Buchungsweg ähnlich A1 |
| **A3** | Verbindliche externe Direktbuchung; vollständige weitere Abwicklung bei uns | Bereits extern verbindlich | Vereinbarten Portalpreis übernehmen; eigene Dokumentation, Gastkontakt, Zahlungsmanagement und Aufenthalt |
| **A4** | Verbindliche externe Buchung mit **geteilter** Abwicklung | Bereits extern verbindlich | Beispielsweise eigenes Vertragsdokument und lokale Leistung, Portalzahlung; andere Verantwortungen je Profil |
| **A5** | Extern weitgehend vollständig abgewickelte Direktbuchung | Bereits extern verbindlich | Keine zweite Annahme/unnötige eigene Mahnung; nur erforderliche eigene lokale Aufgaben und Nachweise |
| **A6** | Eigenbelegung, private Überlassung, Wartung und sonstige Sperren | Interner Belegungsanlass, nicht automatisch Mietvertrag | Einheitlicher Vorgang mit Sperrgrund, Belegung und je nach Fall Gäste, Bestätigung, Zusatzleistungen und Zahlung |
**Partner-/Hub-Vertrieb ist kein A6.** Unterschiedliche Provisionen je Partner sind eine kaufmännische Eigenschaft des Ursprungskanals bzw. der Buchung; eine separate Partnerprozessklasse wird nicht benötigt. Telefon/manuell/iCal/E-Mail/API beschreiben Informations- oder Erfassungskanäle, keine eigenen Archetypen.
## Verhalten im gemeinsamen Prozess
- **A1/A2:** Mit Hold > 0 kann nach geeigneter Belegungssicherung ein bindendes zeitlich befristetes Angebot verschickt werden. **Hold = 0:** reine Preis-/Verfügbarkeitsauskunft unter Vorbehalt; bei Buchungswunsch erneute Prüfung und Bestätigung entsprechend dem automatisch/manuell konfigurierten Modus. Die verbindliche Annahme eines gültigen eigenen Angebots erfordert **keine zweite Freigabe**.
- **A3–A5:** Der Vertrag entstand bereits extern. Der bestätigte Gastpreis und die nachweislich vereinbarten Bedingungen werden übernommen, **nicht durch eigene Preise oder eine zweite Annahme ersetzt**. Es ist zulässig, dass die Gastadresse, Tagespreise oder Zahlungsdetails erst später verfügbar werden.
- **A6:** Jeder eigenständige interne Sperr-/Nutzungsanlass ist ein Vorgang. Private Aufenthalte können Teilnehmer, Kurabgabe, Wäschepakete, Gebühren und Zahlungen haben, auch bei Mietpreis 0. Eine reine Wartungssperre benötigt weder Gast noch Mietvertrag. Der Hold einer A1/A2-Anfrage ist dagegen **keine eigene A6-Buchung**.
- **Alle:** Änderung, Storno/Aufhebung, Belegung, Nachweise, Fristen und Folgeaktivitäten benutzen gemeinsame fachliche Mechanismen. Die rechtliche Wirkung bleibt abhängig vom Vorgangstyp.
## Validierung durch reale Fälle
- [R01 – eigene Website](Szenarien/R01_Eigene_Webseite.md): A1, ggf. A2 nach Datenergänzung.
- [R08 – Destination Solutions](Szenarien/R08_Destination_Solutions.md): **A3** mit vollständig eigener weiterer Abwicklung, manuellen Portalsperren und partnerabhängiger Vermieterprovision.
- [R09 – FeWo-direkt](Szenarien/R09_FeWoDirekt.md): **A4** mit teilweise externer Zahlung/Kommunikation.
- [R07 – interne Belegung/Sperre](Szenarien/R07_Eigenbelegung_und_Sperren.md): **A6**, mit und ohne Gäste.
**Nicht als Fakten unterstellen:** Identische Portal-Datentiefe, allgemeingültige Portal-Stornozuständigkeit, gesicherte Kalenderpropagation oder automatische Erkennbarkeit jedes iCal-Eintrags.
@@ -0,0 +1,51 @@
---
id: K00
typ: fachkonzept
titel: Abwicklungsprofile, Einstellungen und Dokumente
status: fachlicher-arbeitsstand
version: "0.10"
---
# Abwicklungsprofile, Einstellungen und Dokumente
## Konfiguration: Vermieterstandard und Kanalabweichung
**Mandantenregel:** Jeder Vermieter legt seine eigenen **globalen Standardeinstellungen** fest. Für einen Kanal kann er einzelne Werte ausdrücklich überschreiben. Ein **nicht gesetzter Kanalwert** erbt den globalen Vermieterwert. Das gilt auch für `0`, `nein` und `manuell`: Diese bewusst eingestellten Werte sind **keine leeren Werte**. Objekt- und Vorgangskontext beeinflussen weiterhin Preis, Belegung und Vorlagenauswahl, soweit fachlich erforderlich; eine weitergehende Hierarchie wird nicht ohne Entscheidung eingeführt.
Je nach Kanal **und tatsächlicher Eingangsart** werden relevante Regeln angewandt. Es gibt kein automatisches „alle FeWo-direkt-Buchungen sind gleich“. Die Konfiguration ist bewusst schlank: keine frei programmierbare Workflow-Engine erforderlich.
| Konfigurationsbereich | Zweck |
|---|---|
| Automatisch/manuell | Anfrage, Buchungswunsch und zulässige Folgeaktionen nach wirksamem Vermieterstandard oder Kanalabweichung bearbeiten; individuelle manuelle Übernahme möglich |
| Haltefrist | Für eigene/unverbindliche Anfragen: `0` = kein Hold; `>0` = befristete Reservierung mit passend befristetem bindendem Angebot (z. B. 24/48/72 Stunden) |
| Datenbeschaffung | Automatisch, manuell oder kombiniert; vorhandene, unvollständige und unbekannte Portalwerte unterscheiden |
| Verantwortung | Vertrags-/Dokumentenversand, Gastkommunikation, Zahlung, Mahnung, Storno/Erstattung, lokale Leistungen, Kalender-/Sperrpflege |
| Dokumentenprofil | Vorlagen und Anlagen abhängig von Vermieter, Objekt, Kanal, Eingangsart/Vorgangstyp und konkretem Vorgang |
| Konditionsquelle | Eigene Jahres-/Saisonpreise bei eigenem Angebot oder verbindlich akzeptierter Portalpreis bei extern abgeschlossenem Vertrag |
| Kanal-Fähigkeit | iCal/API/E-Mail/Portaloberfläche/manuell; Nachweis, Verzögerung, Vollständigkeit und erforderliche manuelle Schritte |
Bei **Hold = 0** ist die ursprüngliche Mitteilung **kein uneingeschränkt annehmbares Vertragsangebot**. Nach dem erneuten Verfügbarkeitscheck wird der Buchungswunsch gemäß wirksamem Modus automatisch bestätigt oder zur Vermieterentscheidung vorgelegt. Bei einem bereits verbindlich angenommenen Angebot oder extern geschlossenen Vertrag darf diese Wahl die entstandene Verbindlichkeit nicht nachträglich aufheben.
## Dokumentarten und Auswahl
| Sachverhalt | Geeignetes Dokument | Fachliche Wirkung |
|---|---|---|
| Eigene Anfrage mit Hold > 0 | Bindendes befristetes Angebot mit Vertragstext/Anlagen und nachweisbarer Annahmemöglichkeit | Wirksame rechtzeitige Annahme führt zum Vertrag |
| Anfrage mit Hold = 0 | Preis-/Verfügbarkeitsauskunft unter Vorbehalt | Kein Vertrag durch bloße Annahme der Auskunft; Buchungswunsch erfordert neue Prüfung und Bestätigung |
| Externe bindende Direktbuchung A3/A4 | Passende Buchungs-/Vertragsdokumentation der bereits vereinbarten Bedingungen | **Dokumentiert**, begründet nicht durch zweite Annahme einen neuen Vertrag |
| A5 | Ggf. Ergänzung zur externen Bestätigung, Anreise- oder lokale Informationen | Nur soweit eigene Tätigkeit dies erfordert |
| A6 mit privaten Gästen | Aufenthalts-, Buchungs- oder Reservierungsbestätigung, ggf. Zusatzleistungen | Wirkung entsprechend dem tatsächlichen privaten Überlassungsverhältnis |
| A6 ohne Gäste | Interne Bestätigung oder kein Dokument | Kein künstlicher Mietvertrag |
Vor Versand soll der Vermieter bei Bedarf die **gemeinsame Konditions-/Dokumentenzusammenstellung** sehen: Gast/Teilnehmer, Zeitraum, verbindlicher Preis bzw. nachgewiesene Teilbeträge, Leistungen, Stornoregel, gewählte Vorlage/Version und Anlagen. Die zugrunde liegenden Vereinbarungen bleiben mit Quelle und verwendetem Dokumentenstand nachvollziehbar. Für extern verbindliche Buchungen dürfen **keine neuen, nicht akzeptierten Pflichten** stillschweigend eingeführt werden. Bei fehlendem Konditionsnachweis wird die **betroffene Handlung** geklärt; eine bereits gültige Buchung wird nicht rückwirkend als unverbindlich behandelt.
Die Software wählt passende Vorlagen und Folgeaktivitäten automatisch anhand des fachlichen Profils; bei zulässigem Bedarf ist eine **begründete manuelle Korrektur** möglich. Vorlagenwahl darf nicht allein vom Kanal abhängen. Ein Portalkonto kann gemischte Eingangstypen besitzen.
## Preis- und Informationsregeln
- Für eigene Angebote gelten gepflegte **Jahres-/Saisonpreise**, ggf. Rabatte und zusätzliche Leistungen; keine Yield- oder Buchungsklassenlogik im MVP.
- Bei **extern bereits verbindlicher Buchung** ist der vom Gast akzeptierte **Portalpreis** maßgeblich. Die eigene Tarifrechnung darf ihn höchstens vergleichen, nicht unbemerkt ersetzen.
- Portale liefern Einzelpreise, Sammelposten oder lediglich den Gesamtpreis. Alle Formen sind zulässig. Unbekannte Positionen bleiben offen; fehlende Daten dürfen bei Bedarf manuell ergänzt werden.
- Eventuelle Gast-Servicegebühr, Vermittler-/Vermieterprovision, Vertriebspreisaufschlag und Vermieterauszahlung sind verschiedene Sachverhalte, auch wenn ein Portal Beträge kombiniert.
**Vertiefung:** [Preis- und Zahlungslogik](Querschnitt/Preise_und_Zahlungen.md) · [Gates](Querschnitt/Gates_und_Nachweise.md).
@@ -1,174 +0,0 @@
---
id: A04-DOK-01
typ: prozessanalyse
titel: FeWo-direkt – Vertragsvorlage und Einordnung in den A4-Istprozess
status: diskussionsentwurf
version: "0.6"
stand: 2026-10-31
prozess: V01
archetyp: A4
quellen:
- "Vorlage MV für fewo-direkt.pdf (4 Seiten, Betreiber)"
- "Betreiberbeschreibung: manueller A4-Istprozess, 31.10.2026"
---
# A4 – Vertragsvorlage und Prozessanalyse
> **Arbeitsdokument, keine Freigabe zur Änderung rechtlicher Klauseln.** Die Vertragsvorlage ist ein Beispiel für den aktuellen Ablauf, kein Nachweis der beim Buchungsabschluss über FeWo-direkt tatsächlich akzeptierten Konditionen. **Zugangscodes, Passwörter, persönliche Kontaktdaten und Namen von Gästen werden hier bewusst nicht reproduziert.**
## 1. Einordnung in den dokumentierten Istprozess
1. FeWo-direkt bestätigt extern eine verbindliche Buchung und sendet eine E-Mail mit Gastname und Zeitraum.
2. Der Vermieter sperrt andere Belegungskalender manuell.
3. Im FeWo-direkt-Vermieterbereich werden verfügbare Gastkontakte und Buchungs-/Preisdaten ermittelt.
4. Fehlende Angaben aller tatsächlich erforderlichen Reisenden werden per Gastkontakt angefordert.
5. Der Vermieter erstellt einen individuellen Mietvertrag anhand der vierseitigen Vorlage und versendet ihn mit der Internetvereinbarung.
6. FeWo-direkt fordert Anzahlung und Restzahlung an und verarbeitet diese. **Korrektur durch Screenshots vom 31.10.2026:** In der einzelnen Buchungs-Kommunikation ist ein Zahlungsplan mit Raten, Fälligkeiten und Zahlungsmarkierung sichtbar; die vollständige Zahlungs-, Gebühren- und Auszahlungstransparenz bleibt unbewiesen.
7. FeWo-direkt versendet ca. 72 Stunden vor Check-in eine Gastinformation (Betreiberangabe).
8. Vermieter informiert lokale Dienstleister (Schlüssel, Reinigung, Gästebetreuung).
9. Stornierungen werden nach aktueller Praxis über FeWo-direkt abgewickelt; konkrete Verantwortlichkeiten und Statusübermittlung sind noch zu prüfen.
### Nachtrag: vom Betreiber bestätigte Portalpraxis (31.10.2026)
- **Der eigene vierseitige Mietvertrag ist nicht im FeWo-direkt-Inserat hinterlegt.** Gäste erhalten ihn erst im nachgelagerten eigenen Versand, soweit der derzeitige Ablauf beschrieben ist.
- Der Betreiber **kann derzeit nicht einsehen**, welche Buchungs-/Vertragsunterlagen FeWo-direkt dem Gast im konkreten Abschluss zusendet. Deshalb ist **nicht nachgewiesen**, welche Klauseln der Gast wann erhält und akzeptiert.
- **Mietpreise müssen nach bisheriger Praxis im FeWo-direkt-Kalender gepflegt werden**; Rabatte und Stornobedingungen werden ebenfalls im Portal verwaltet. Der bei Buchung vereinbarte Portalkonditionsstand ist für diese Buchung maßgeblich und darf nicht durch unsere eigene Kalkulation ersetzt werden.
- Dies ist ein **konkretes Kanalprofil A4**, **keine allgemeine Regel** für andere Portale. Andere Kanäle können Preise, Konditionen, Vertrag und Abwicklung anders verteilen.
- **Die Vertragsvorlage wird passend zu Portal, tatsächlichem Buchungstyp und ggf. Herkunft ausgewählt**. Andere Portale können eigene Vorlagen und Anlagen erfordern; bestehende Vertragsdokumente werden versioniert.
## 2. Was die vierseitige Vorlage derzeit enthält
| Textabschnitt | Inhalt | Prozesszuordnung |
|---|---|---|
| Präambel, § 1–2 | Vertragsparteien, konkrete Ferienwohnung, Zeitraum, An-/Abreisezeiten | P02/P04 |
| § 2–3 | Schlüsselübergabe durch lokalen Dienstleister, Kurabgabe/Anmeldung | P04 |
| § 4 | Mietsumme einschließlich verschiedener Kosten; Portal-Servicegebühr; Anzahlung/Restzahlung | P02/P03 |
| § 5 | 'Annahme' des Vertrages durch Anzahlung; Sorgfalt/Schäden | P02 / Sonderfall |
| § 6–9 | Wäsche, Sauna, Schlüssel, Hausordnung | P04 |
| § 10–12 | Sorgfalt, Beanstandungen, Rauchverbot, Internet und Internetvereinbarung | P02/P04 |
| § 13 | Rücktritt: 60+ Tage 0 %, 59–30 Tage 50 %, ab 29 Tage 100 % des Mietpreises; Ersatzmieterregelung | Sonderprozess Stornierung |
| § 14 | Abreise- und Reinigungsanforderungen | P04/P05 |
| § 15–18 | Gerichtsstand, Form, Datenschutz, salvatorische Klausel | Recht/Compliance |
| Anlage Seite 4 | Internetnutzung, WLAN-Zugang, Gerätehinweise | Gästeinformation/Sicherheitsdaten |
## 3. Wesentliche Befunde und Prüfaufträge
**F-01 – Verbindlichkeit (§ 5), hohe Priorität.** Die Klausel setzt 'Annahme des Vertrages' mit einer bereits gezahlten Anzahlung in Zusammenhang. Nach der fachlich angenommenen A4-Logik besteht die bindende Portalbuchung aber **vor** unserem späteren Dokumentenversand. Es ist zu prüfen, was vor Vertragsschluss auf FeWo-direkt bereitgestellt wurde. Ein nachgeschicktes PDF darf neue Bedingungen nicht stillschweigend zur bisherigen Buchung hinzufügen. **Fachliches Soll:** Trennung zwischen Nachweis der externen Buchung und nachgelagerter Übermittlung bestehender Bedingungen.
**F-02 – Vollständige Konditionen vor Buchung, hohe Priorität.** Der bisherige Ablauf lässt offen, ob Hausordnung, Internetanlage, Stornoregel, Zusatzleistungen und weitere Bedingungen vor dem FeWo-direkt-Klick einsehbar waren. Die offiziellen Vermieter-AGB verlangen die Offenlegung der jeweiligen Konditionen und erlauben Zusatzvereinbarungen nur im Einklang mit den zuvor veröffentlichten Informationen. **Bestätigter Ist-Zustand:** Die PDF-Vorlage ist nicht im Inserat hinterlegt. **Offen:** Welche Vertragsbedingungen und Unterlagen FeWo-direkt im konkreten Abschluss anzeigt oder übersendet, kann der Betreiber derzeit nicht nachvollziehen. Ob eine Hinterlegung sinnvoll ist, bleibt eine optionale Maßnahme, keine allgemeine Systemvorgabe. Die konkret angezeigten Bedingungen sind gesondert zu ermitteln.
**F-03 – Preisstruktur (§ 4), hohe Priorität.** Das Dokument nennt Gesamtbetrag, Endreinigung, Betreuung, Servicegebühr des Portals, Anzahlung und Restzahlung in einem Text. Erforderlich sind fachlich getrennte Werte: vom Gast verbindlich vereinbarte Gesamtkonditionen, darin enthaltene Unterkunfts-/Leistungsentgelte, ggf. separate Reisenden-Servicegebühr des Portals, Vermieterprovision, Auszahlungsbetrag und Zahlungsstatus. **Keine zusätzlichen Beträge durch FewoPortal erheben, die nicht Bestandteil der Vereinbarung sind.** Konkrete Gebührenstruktur im Vermieter-/Gastbeleg gegenprüfen.
**F-04 – Storno (§ 13), hohe Priorität.** Die Vorlage enthält die oben genannten Staffeln. Nicht belegt ist, ob exakt diese Staffel für die konkrete FeWo-direkt-Buchung vor Abschluss angezeigt und vereinbart wurde. Der Gast kann laut FeWo-direkt über sein Konto stornieren; Erstattungen richten sich nach der anwendbaren Richtlinie. Der Vermieter darf daher aus der nachträglich versandten Vorlage keine abweichenden Gebühren ableiten. Vermieterseitige Stornierungen sind zusätzlich durch FeWo-direkt-Sanktionsregeln besonders riskant.
**F-05 – Gast- und Meldedaten (§ 3), mittlere Priorität.** Der Vertrag sieht die örtliche Anmeldung durch einen Dienstleister und die Kurabgabe vor. Welche Felder für wen und zu welchem Zeitpunkt rechtlich erforderlich sind, muss anhand der kommunalen Vorgaben gesondert definiert werden. Die im Vertrag genannten Tarife und Altersgrenzen stimmen mit der derzeit öffentlich ausgewiesenen Kühlungsborner Information überein, sollten aber nicht dauerhaft als fixe Vertragskonstanten im Produkt behandelt werden.
**F-06 – Rechtlich prüfbedürftige Vertragsklauseln, hohe Priorität.** Besonders § 10–11 (pauschale Einschränkungen von Mietminderung/Beanstandungen), § 15 (vorgegebener Gerichtsstand Dortmund für private Gäste), § 16 (Schriftform/E-Mail), § 17 (Datenverwendung/Übermittlung an Dienstleister) und die Formulierung zur maschinellen Unterschrift sind juristisch zu prüfen. Die Wirksamkeit ist nicht allein aus dieser Analyse abschließend zu beurteilen.
**F-07 – Zugangsdaten und Anlagen, hohe Priorität.** Seite 2 und 4 enthalten feste Zutritts-/WLAN-Daten. Diese sollten nicht dauerhaft Bestandteil der allgemeinen, archivierten Vertragsvorlage sein. Empfehlung: separate, gezielt zur Anreise freigegebene Gästeinformation. Bereits offengelegte Zugangsdaten kontrollieren/ggf. wechseln. Eine separate Internet-Nutzungsvereinbarung ist fachlich eine versionierte Anlage, muss aber in ihrem rechtlichen Status geklärt sein.
**F-08 – Unterschiedliche Dokumentzwecke, mittlere Priorität.** Vertrags-/Konditionsnachweis, ortsbezogene Aufenthaltshinweise und sensible Zugriffsinformationen nicht zwingend in einem vierseitigen 'Mietvertrag' bündeln. Ziel: **ein gemeinsames, einfaches FewoPortal-Dokumentenmanagement** mit richtigem Zeitpunkt der Bereitstellung, kein neues eigenständiges Buchungsformular.
**F-09 – Datenqualität, mittlere Priorität.** Die konkrete Vorlage enthält variable, noch unbesetzte Felder (z. B. Reisende, Daten, Preis, Nächte). Beim Dokumenterstellen müssen Vollständigkeit, Übereinstimmung mit der Portalbuchung und Version der gültigen Anlagen geprüft werden; bei einem Konflikt wird der Versand gesperrt bzw. eine Klärung ausgelöst.
## 4. Soll-Funktionsbild für A4 (noch nicht beschlossen)
**Bindungsnachweis aus FeWo-direkt** → **Portalpreis und bei Buchung vereinbarte Konditionen übernehmen** → **Gastdaten gezielt nachfordern** → **Dokumente aus verifiziertem Konditionsstand erstellen und ohne zweite Annahme übermitteln** → **Portalzahlungen/Storno extern verfolgen, ohne Zahlungen zu erfinden** → **separate Anreiseinformationen und Dienstleisteraufgaben auslösen**.
Bei einer Abweichung zwischen dem vom Gast akzeptierten Konditionsstand und dem späteren Dokument **nicht automatisch ein abweichendes Vertragsdokument verschicken**, sondern in FewoPortal einen Klärungsfall eröffnen.
## 5. Noch offene fachliche Klärung
**Welche Konditionen sieht und bestätigt der Gast bei einer konkreten FeWo-direkt-Direktbuchung und welche Dokumente erhält er anschließend tatsächlich vom Portal?**
Der nachträgliche eigene Mietvertrag ist **nicht** vorab hinterlegt. Ein extern zu prüfender Beispielbuchungsablauf bzw. belegbarer Buchungsauszug soll die tatsächlichen Konditionen und Dokumente identifizieren; die Buchung bleibt schon vor unserer Datennachforderung verbindlich, soweit der Portalabschluss dies belegt. Auf Basis dieser Feststellung wird je Kanal die passende **versionierte eigene Vertrags-/Dokumentenvorlage** zugeordnet. Siehe [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile und Vertragsvorlagen]].
## 6. Öffentliche Quellen für die juristisch-technischen Prüfpunkte
- [FeWo-direkt – AGB für Vermieter (29.10.2026), insb. Nr. 2.2–2.3](https://www.fewo-direkt.de/lp/b/partner-terms-of-use)
- [FeWo-direkt – Hochladen Ihres Mietvertrags](https://hilfe.fewo-direkt.de/articles/Wie-kann-ich-meinen-Mietvertrag-hochladen)
- [FeWo-direkt – Stornierungen durch Gäste](https://hilfe.fewo-direkt.de/articles/Kann-ein-Urlauber-eine-Reservierung-stornieren)
- [FeWo-direkt – Richtlinie für Gastgeberstornierungen](https://www.fewo-direkt.de/tlp/trust-and-safety/partner-initiated-cancellation-policy)
- [§ 305 BGB – Einbeziehung von AGB](https://www.gesetze-im-internet.de/bgb/__305.html)
- [§ 307 BGB – Inhaltskontrolle](https://www.gesetze-im-internet.de/bgb/__307.html)
- [§ 309 Nr. 5 BGB – Pauschalierter Schadensersatz](https://www.gesetze-im-internet.de/bgb/__309.html)
- [§ 536 BGB – Mietminderung](https://www.gesetze-im-internet.de/bgb/__536.html)
- [§ 38 ZPO – Gerichtsstandsvereinbarung](https://www.gesetze-im-internet.de/zpo/__38.html)
- [§ 126 BGB – Schriftform](https://www.gesetze-im-internet.de/bgb/__126.html), [§ 127 BGB – Vereinbarte Form](https://www.gesetze-im-internet.de/bgb/__127.html)
- [Kühlungsborn – Kurabgabe](https://www.kuehlungsborn.de/kurabgabe/)
**Abgrenzung:** Dies ist eine fachliche Prozess- und Risikoprüfung, keine rechtliche Freigabe und keine eigenmächtige Überarbeitung der Betreiber-Vertragstexte.
## 7. Nachtrag aus belegten Bildschirmansichten (31.10.2026) – Ist-Zustand, nicht allgemeines Portalverhalten
**Quelle:** Vier Screenshots aus dem FeWo-direkt-Vermieterbereich zu einer konkreten, erst im Juli 2027 stattfindenden Buchung. Gastname, Buchungsreferenz und Unterkunfts-ID werden aus Datenschutzgründen hier nicht reproduziert. Die Screenshots belegen die Anzeige in dieser Buchung, nicht automatisch die generelle Exportierbarkeit oder die vertragsrechtliche Richtigkeit.
### 7.1 Nachgewiesene Buchungs- und Zahlungsinformationen
| Datenpunkt | In der konkreten Buchung sichtbar | Bedeutung / Grenze |
|---|---|---|
| Zeitraum und Gäste | 10.–17.07.2027, sieben Nächte, zwei Erwachsene | Belegungssachverhalt, keine vollständigen Gaststammdaten |
| Übernachtungspreis | 840,00 € über sieben Nächte | Aggregierter Betrag, keine einzelnen Tagespreise |
| Rabatt | −42,00 € | Rabattbetrag bekannt, Berechnungs-/Aktionsregel nicht belegt |
| Gebühren und Steuern | 181,51 € | Als Summe ausgewiesen, Einzelbestandteile nicht nachgewiesen |
| Gesamtzahlung des Gastes | 979,51 € | Rechnerisch 840 − 42 + 181,51; kann gastseitige Gebühren enthalten |
| An FeWo-direkt gezahlt | −84,82 € | So beschriftet; genaue Gebührenart/Zuordnung nicht belegt |
| Ausgewiesene Gesamtauszahlung | 894,69 € | Rechnerisch 979,51 − 84,82 |
| Andere Buchungsübersicht | **900,20 € voraussichtliche Auszahlung** | **Abweichung von 5,51 €** zur Zahlungsübersicht; ungeklärt, nicht als korrekt/fehlerhaft einstufen |
| Rate 1 von 2 | 390,61 €, als bezahlt am 01.10.2026 markiert | Nachweis eines Portal-Zahlungsstatus, **kein Bank-Auszahlungsnachweis** |
| Rate 2 von 2 | 588,90 €, fällig am 12.06.2027 | In Screenshot nicht als bezahlt ausgewiesen; beide Raten zusammen ergeben 979,51 € |
| Voraussichtliche Vermieterauszahlung | 11.07.2027 angekündigt | Geplantes Ereignis, nicht als tatsächlich ausgeführt nachgewiesen |
| Stornoübersicht | 100 % Erstattung bei mehr als 60 Tagen; 50 % bei mehr als 30 Tagen; keine Erstattung bei weniger als 30 Tagen | Angezeigte Portalbedingungen; Grenzfall bei exakt 60/30 Tagen und rechtliche Einbeziehung separat prüfen |
| Zugangsinformationen | Portal kündigt Gäste-E-Mail 72 Stunden vor Check-in an, zeigt Schlüsselabholart und Vorschautext | Angekündigter Portalversand, **kein Versand-/Empfangsnachweis** |
**Korrektur früherer Aussage:** Nicht „keine Zahlungsinformationen zugänglich“, sondern **teilweise buchungsbezogene Zahlungsinformationen in der Kommunikationsansicht zugänglich**. Der Betreiber berichtete weiterhin über fehlenden brauchbaren allgemeinen Export/Zahlungsverlauf und fehlende vollständige Einzelpreis-/Gebührenaufschlüsselung. Dies bleibt als Beobachtung bestehen, sofern nicht durch andere Ansichten widerlegt.
### 7.2 Auswirkungen auf den generischen Prozess
- **P02/G2 – Konditionen:** Gesamtpreis, Rabatt, angezeigte Gebühren, Stornoregel und Quelle getrennt mit Nachweis speichern; unbekannte Einzelpreise oder Gebührenarten **nicht rekonstruieren oder schätzen**.
- **P03/G3 – Zahlungen:** Separate Zustände für *Rate fällig*, *Rate laut Portal bezahlt*, *Vermieterauszahlung erwartet* und *Vermieterauszahlung tatsächlich eingegangen*. Die Markierung „bezahlt“ ist **kein Nachweis der Auszahlung an den Vermieter**.
- **P03 – Abrechnungskonflikt:** Unterschied 900,20 € vs. 894,69 € als konkreter Klärungsfall; nicht automatisch einen der beiden Beträge überschreiben.
- **P04 – Anreise:** Geplante E-Mail 72 Stunden vor Check-in als externe Kommunikationsaktivität berücksichtigen; dokumentieren, ob tatsächliche Versendung oder nur Ankündigung bekannt ist.
- **Portabilität:** Der Screenshotsatz ist eine **Portalreferenz A4**, kein festverdrahtetes Datenmodell für alle externen Kanäle.
### 7.3 Unverändert offene Prüfpunkte
1. Ergebnis von **„Vollständige Zahlungsdetails ansehen“**: Gibt es eine tiefere Aufschlüsselung der 181,51 € und der 84,82 €?
2. Ursache der **5,51-€-Differenz** zwischen zwei angezeigten Auszahlungsbeträgen.
3. Nachweis tatsächlicher Auszahlungen und belastbarer Status-/Exportmöglichkeit für abgeschlossene Buchungen.
4. Welche Bedingungen und Bestätigungsunterlagen erhält der Gast beim verbindlichen Portalabschluss?
5. Umfang der benötigten und tatsächlich bereitgestellten Gäste- und Meldedaten.
**Bewertungsregel:** Beobachtete Portaloberfläche, fachliche Interpretation und noch nicht geprüfte Annahmen konsequent getrennt führen.
## 8. Buchungsänderung und Storno – geprüfter Erkenntnisstand (31.10.2026)
**Ist-Praxis (Betreiber):** Bislang wurden weder eine Vermieterstornierung noch eine Buchungsänderung selbst durchgeführt. Bei Konflikten oder Doppelbuchungen wurde versucht, den Gast zur Stornierung zu bewegen. Das ist keine freigegebene Soll-Regel.
**Offiziell von FeWo-direkt beschrieben:** Gäste können selbst stornieren oder eine Stornierungsanfrage stellen. Gäste können Änderungsanfragen für Daten, Gästezahl oder Check-in stellen; Vermieter können solche Anfragen bearbeiten, ggf. mit neuer Preis-/Steuerberechnung. Gastgeber können über ihr Vermieterkonto stornieren, müssen mit Gebühren/Sanktionen rechnen und können in bestimmten begründeten Fällen einen Stornierungsverzicht beantragen. Doppelbuchungen des Gastgebers gelten grundsätzlich als gastgeberveranlasster Stornogrund. Die Richtlinie untersagt es ausdrücklich, Gäste zur Stornierung zu bewegen, um Sanktionen für den Gastgeber zu umgehen. Der bloße persönliche Konflikt mit einem Gast ist keine gesicherte Ausnahme; mögliche Hausregelverstöße müssen konkret geprüft werden.
**Generische Prozessanforderung:** Für jeden Änderungs-/Stornofall Ursache, tatsächlichen Initiator, technisch ausführenden Beteiligten, Verantwortlichen für Entscheidung/Erstattung, Ausführungs- und Nachweisstatus sowie Folgen für Konditionen, Vertrag, Belegung und Zahlung getrennt führen. Eine Storno-/Änderungsanfrage verändert nicht automatisch eine verbindliche Buchung. Datenquellen können je Portal unterschiedlich sein (Portal, API, E-Mail, iCal, manuell).
**Weiter ungeklärt:** Tatsächliche Benachrichtigungs- und Statusübermittlung an FewoPortal; Ablauf/Fristen und Nachweise im konkreten Konto; Verfahren anderer Portale.
**Offizielle Quellen:**
- https://hilfe.fewo-direkt.de/articles/Kann-ein-Urlauber-eine-Reservierung-stornieren
- https://hilfe.fewo-direkt.de/articles/Accept-or-decline-a-guest-s-change-request
- https://hilfe.fewo-direkt.de/articles/Die-Reservierung-eines-Gastes-stornieren
- https://www.fewo-direkt.de/tlp/trust-and-safety/partner-initiated-cancellation-policy
## 9. Einordnung nach Gesamt-Konsolidierung v0.7
1. **A4 bleibt realer Praxisfall**, nicht Muster für alle Portale. FeWo-direkt zeigt in einer Buchung im Posteingang Zahlungsplan, einige aggregierte Preisbestandteile, Gäste-Gesamtzahlung, Abzug und erwartete Auszahlung; eine lückenlose Einzelpreis-/Gebührentransparenz und eine konsistente Auszahlungsübersicht sind weiter **nicht nachgewiesen**. Das frühere pauschale Urteil „keinerlei Zahlungsdaten“ ist überholt; konkrete Screenshots in Abschnitt 7 sind maßgeblich.
2. **Ical-Verzögerung:** Direkte Buchung kann vor Verarbeitung einer anderswo veranlassten Blockierung verbindlich werden. FewoPortal darf eigene erfolgreiche Exporte nicht als Portal- oder Partnernetzbestätigung behandeln. Die Idee eines 10-Minuten-Freigabefensters ist **kein aktuell verfügbarer A4-Prozess**.
3. **Vertragsdokumente:** Der eigene vierseitige Vertrag wird bisher nach der Portalbuchung versandt und ist nicht als statisches PDF in FeWo-direkt hinterlegt; Inhalt der dem Gast vor/bei Buchung gezeigten Bedingungen bleibt zu verifizieren. Statische allgemeine Bedingungen von individuellen Preis-/Zahlungsdetails trennen; keine still nachgeschobenen Verpflichtungen.
4. **Sonderprozesse:** Bisher keine konkret selbst durchlaufene FeWo-direkt-Buchungsänderung und keine eigene Vermieterstornierung. Kein nicht erprobtes Verfahren als gelebte Praxis behaupten. Differenzierung **tatsächliche Stornoursache, Antragsteller, ausführender Beteiligter** beachten.
5. **Abrechnung:** Unbekannte Gast-Servicegebühren, Portalabzüge, Vermieterprovisionen oder kombinierte Sammelpositionen müssen nicht künstlich zerlegt werden. Portalinformationen und manuelle Ergänzungen mit Quelle sichern; bei abweichenden Summen Klärungsaufgabe.
Fachliche Konkretisierung: [[K01_Preisstruktur_und_Abrechnung|K01]], [[X01_Belegungskonflikte_und_Sperrnachweise|X01]] und [[O00_Offene_Portalprueffaelle|O00]]. Keine Aktualisierung oder juristische Freigabe des ursprünglichen PDF-Vertrags durch diese Analyse.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[00_Buchungsarchetypen|Archetypen]] · [[00_Portalprofile_und_Vertragsvorlagen|Vertragsprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[O00_Offene_Portalprueffaelle|Offene Prüffälle]] · [[P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse_historisch|Frühere Fassung im P03-Archiv]]
@@ -1,184 +0,0 @@
--- a/00_Prozesslandkarte.md
+++ b/00_Prozesslandkarte.md
@@ -1,4 +1,5 @@
-# 00 – Prozesslandkarte FewoPortal
+
+# 00 – Prozesslandkarte FewoPortal v0.5
**Status:** gemeinsamer Arbeitsstand; übergreifendes Modell, nicht vollständig freigegeben.
**Stand:** 31.10.2026
@@ -35,7 +36,7 @@
| **P02** | Konditionen & Buchungsverbindlichkeit | Verbindlichkeit durch fristgerechte Annahme des **von uns bindenden Angebots** oder Nachweis einer schon verbindlichen Portalbuchung; gültige Konditionen revisionsfähig festgehalten |
| **P03** | Buchungsverwaltung & kaufmännische Abwicklung | Vertragsdokumente, Zahlungszuständigkeit, Fristen und Verwaltungsaufgaben gesteuert, auch bei extern verantworteten Aktivitäten |
| **P04** | Leistungsvorbereitung & Aufenthalt | Informationen und lokale Leistungen bereitgestellt; Anreise, Aufenthalt, Abreise betreut |
-| **P05** | Abschluss & Nachbereitung | Offene Vorgänge transparent; Abschluss, Feedback und objektbezogene Folgeaufgaben; zulässige Übergabe an V02 |
+| **P05** | Abschluss & Nachbereitung | Buchungs- und Leistungserbringung fachlich abgeschlossen; offene, danach eigenständig zu bearbeitende Fälle kontrolliert an Folgeprozesse übergeben; Feedback und objektbezogene Folgeaufgaben; zulässige Übergabe an V02 |
### V02 – Vermarktung, Gästegewinnung und Gästebindung (fachlich vorgesehen, Details später)
@@ -84,15 +85,17 @@
- X08: No-show, vorzeitige Abreise, Verlängerung
- X09: Reklamation, Schaden, Kaution und Nachforderung
-Ein Sonderprozess kann mehrere Phasen betreffen und verwendet dieselbe Buchungsakte und Ereignishistorie.
+Ein Sonderprozess kann mehrere Phasen betreffen und verwendet dieselbe Buchungsakte und Ereignishistorie. **Nach abgeschlossenem Buchungs- und Leistungsprozess** können noch offene Ansprüche oder Konflikte als eigenständig zu bearbeitende Folgeprozesse weitergeführt werden; die Referenz auf die ursprüngliche Buchung und der Übergabenachweis bleiben erhalten (E-010).
## F. Zentrale Gate-Philosophie
+
+**P05-Abschluss-/Übergabegate (E-010):** Abschluss der Buchungs- und Leistungserbringung ist vom Ende nachlaufender Forderungs-, Schadens- oder Streitfälle zu unterscheiden. Offene Fälle werden mit Kontext, Verantwortlichkeit und Referenz zur Buchung an den jeweils zuständigen Folgeprozess übergeben. Die endgültigen Pflichtkriterien und Zustände werden in P05 spezifiziert.
Gates dokumentieren **Trigger, erwartetes Ergebnis, erforderliche Daten, Herkunft/Nachweis, zuständige Stelle, Ergebnisstatus, Folgeschritt**. Pflichtinformationen sind **aktivitätsbezogen**, nicht für alle Portale pauschal identisch. Fehlende Adressdaten dürfen eine durch Portalnachweis verbindliche Buchung nicht entwerten; sie blockieren nur Tätigkeiten, für die sie wirklich erforderlich sind.
## G. Noch zu entscheiden
-1. Fachlicher Abschluss von V01 bei offenen Rechnungen, Schäden oder Portalrückmeldungen.
+1. **Detailkriterien für den fachlichen Abschluss von V01:** Welche Leistungen, Informationen und Übergaben müssen konkret abgeschlossen sein? Die Grundentscheidung ist getroffen: Nachlaufende Forderungen/Schäden blockieren nicht allein den Abschluss der Buchungs- und Leistungserbringung, wenn sie nachvollziehbar an einen verantwortlichen Folgeprozess übergeben wurden (E-010).
2. Detailschnitt der buchungsbezogenen Objektaufgaben zu P04/P05; **keine Entscheidung für ein eigenständiges Objektmanagement-Modul**.
3. Genauer Status- und Gate-Katalog, insbesondere Synchronisationssicherheit und externe Stornoereignisse.
4. Abgrenzung P03/P04; Relevanz und Nachweisbarkeit der lokalen Prozesse.
--- a/E00_Entscheidungsprotokoll.md
+++ b/E00_Entscheidungsprotokoll.md
@@ -1,3 +1,4 @@
+
# E00 – Entscheidungsprotokoll
**Stand:** 31.10.2026. Entscheidungen sind fachliche Betreiberfestlegungen, keine bestätigte Rechtsprüfung oder Implementierungsfreigabe.
@@ -13,9 +14,10 @@
| **E-007** | Beschlossen / Betreiberpräzisierung | Produktfokus: Eigene Website als zentraler Einstieg für einen Vermieter mit typischerweise **1–3 Ferienwohnungen**; mehrere Mandanten möglich; **kein Marktplatz**. Primär Gästegewinnung, Buchung und weitgehend automatisierte Abwicklung, nicht umfangreiche Haus-/Objektverwaltung. |
| **E-008** | Beschlossen / Betreiberpräzisierung | V02 umfasst **Multichannel-Marketing und Gästegewinnung** (eigene Website, Social Media, Print, externe Portale) **sowie CRM, Stammkundenmanagement und Loyalty**. Damit ist V02 nicht nur Folgeprozess, sondern auch vorgelagert. Feedback/Bewertungen bleiben in V01. Detaillierung von V02 folgt später. |
| **E-009** | Beschlossen / Betreiberpräzisierung | Buchungsbezogene Objektaufgaben (Reinigung, Schlüsselübergabe, lokale Leistungen) im Hauptprozess **einfach und integriert** behandeln. Die fachliche Existenz von Supportprozessen bedeutet **keine Pflicht zu eigenen Verwaltungsmodulen**. Erweiterte Objektverwaltung, Dienstleister-/Personalplanung und Vermittlungsagentur-Funktionen derzeit nicht priorisieren; Erweiterbarkeit offenhalten. |
+| **E-010** | Grundsatz bestätigt / Details offen | Der Hauptwertschöpfungsprozess V01 endet fachlich mit Abschluss der Buchungs- und Leistungserbringung. Danach weiterlaufende Forderungs-, Schaden- oder Streitfälle sind **an zuständige Folgeprozesse zu übergeben**, anstatt den gesamten Buchungsprozess künstlich offen zu halten. Zusammenhang zur Buchung, Zuständigkeit und Übergabe müssen nachvollziehbar bleiben. Das genaue Abschluss-Gate ist noch zu spezifizieren. |
## Offene Grundsatzentscheidungen
-- Fachliche Abschlusskriterien von V01 bei nachlaufenden Forderungen/Schäden/Portalstatus.
+- Konkrete Mindestkriterien für P05-Abschluss, Übergabenachweis und Zuständigkeit der Folgeprozesse; Umgang mit abgebrochenen oder stornierten Vorgängen.
- Detailschnitt der buchungsbezogenen Objektaufgaben zu P04/P05; Umfang späterer buchungsunabhängiger Funktionen.
- Exakter Mindest-Nachweis und Datenumfang je externem Portalprofil.
@@ -29,4 +31,4 @@
## Dokumentationsregel (Arbeitsvereinbarung)
-Die bestehende Gitea-Dokumentation ist die führende Ablage. Es gibt **eine aktuelle Markdown-Datei je Thema**, P01–P05 dürfen jeweils mehrere Unterdokumente enthalten. Bei **neuen Markdown-Dateien** einen knappen YAML-Header (`id`, `typ`, `titel`, `status`) verwenden. Bestehende Abschnitte bei Fortschreibungen nicht still kürzen oder löschen; fachliche Entscheidungen mit ID verknüpfen und Änderungen per Git-Diff kontrollieren. **Keine implizite Freigabe von Implementierung oder Go-live.**
+Die bestehende Gitea-Dokumentation ist die führende Ablage. Es gibt **eine aktuelle Markdown-Datei je Thema**, P01–P05 dürfen jeweils mehrere Unterdokumente enthalten. Bei **neuen und fachlich aktualisierten Markdown-Dateien** einen knappen YAML-Header (`id`, `typ`, `titel`, `status`, `version`) verwenden. Bestehende Abschnitte bei Fortschreibungen nicht still kürzen oder löschen; fachliche Entscheidungen mit ID verknüpfen und Änderungen per Git-Diff kontrollieren. **Keine implizite Freigabe von Implementierung oder Go-live.**
--- a/G00_Gates_und_Uebergaben.md
+++ b/G00_Gates_und_Uebergaben.md
@@ -1,3 +1,4 @@
+
# G00 – Gate- und Übergabemodell (Arbeitsstand)
## Grundregel
@@ -23,5 +24,10 @@
- **GD:** Erforderliche Gästedaten für lokale Abwicklung liegen vor; darf auch nach GC offen sein.
- **GE:** Externer Portalprozess vollständig verantwortet: für lokale Abwicklung notwendige Informationen vorhanden, extern zuständige Vorgänge ausgewiesen.
+## P05 – Abschluss- und Folgeprozess-Übergabe (Grundsatz E-010)
+- **Abschluss V01:** Fachliche Buchungs- und Leistungserbringung ist beendet; ein ausstehender Anspruch allein blockiert den Prozessabschluss nicht, wenn dessen Bearbeitung wirksam an einen verantwortlichen Folgeprozess übergeben wurde.
+- **Übergabe:** Benötigt mindestens Referenz zur ursprünglichen Buchung, Beschreibung des offenen Sachverhalts, verantwortliche Stelle und nachweisbaren Übergabestatus. Detailumfang und Automatismus bleiben offen.
+- **Status:** Buchungsprozess abgeschlossen und Folgeprozess offen sind gleichzeitig möglich. Die technische Ausgestaltung der Akte ist noch nicht beschlossen.
+
## Noch offen
-Konkrete Gatepflichten je Portal; Identität und Nachweisformat; Konflikt- und Synchronisationsfälle; Umfang externer Statusmeldungen; manueller Freigabepunkt.
+Detailkriterien für das P05-Abschlussgate und die Behandlung von Storno-/Abbruch-Ausgängen; konkrete Gatepflichten je Portal; Identität und Nachweisformat; Konflikt- und Synchronisationsfälle; Umfang externer Statusmeldungen; manueller Freigabepunkt.
--- a/S00_Supportprozesse.md
+++ b/S00_Supportprozesse.md
@@ -1,3 +1,4 @@
+
# S00 – Supportprozesse (vorläufiger Katalog)
Diese Prozesse unterstützen V01 und V02. **Produktmandat E-007 bis E-009:** FewoPortal richtet sich zunächst an Vermieter mit typischerweise 1–3 Ferienwohnungen, mehreren möglichen Mandanten, aber **ohne Marktplatz-/Agentur-Schwerpunkt**. Ein fachlicher Supportprozess rechtfertigt **kein eigenständiges Softwaremodul**. Buchungsbezogene Aufgaben sind möglichst in der Buchungsakte integriert und automatisiert; weitergehende Objektverwaltung bleibt Zukunftsoption.
--- a/X00_Sonderprozesse.md
+++ b/X00_Sonderprozesse.md
@@ -1,3 +1,4 @@
+
# X00 – Sonder- und Ausnahmeprozesse (vorläufiger Katalog)
Sonderprozesse können aus unterschiedlichen Phasen starten. Sie nutzen dieselbe Vorgangsakte; keine parallelen Buchungsformulare/-workflows.
@@ -14,4 +15,6 @@
| X08 | Aufenthaltsabweichung | No-show, Verlängerung, vorzeitige Abreise |
| X09 | Schäden/Reklamation | Mangel, Schaden, Kaution/Nachforderung |
+**Prozessübergabe nach V01 (E-010):** Nach Abschluss der Buchungs- und Leistungserbringung noch offene Fälle (z. B. Schadenersatzforderung, Erstattung, Streitfall) werden an einen zuständigen Folgeprozess übergeben. Sie bleiben mit der ursprünglichen Buchung verbunden. Ob dafür ein separater Vorgang oder eine verknüpfte Aktivität angelegt wird, ist noch nicht entschieden.
+
**Rechtsfragen separat:** Für externe Vollabwicklung liegt die Vertrags-/Mahn-/Storno-Verantwortung beim Portal gemäß vertraglicher Vereinbarung; FewoPortal braucht einen nachvollziehbaren Übergabestatus und mindestens die für eigene Pflichten nötigen Informationen.
--- a/README.md
+++ b/README.md
@@ -1,18 +1,19 @@
-# FewoPortal – Prozessarchitektur v0.4
+
+# FewoPortal – Prozessarchitektur v0.5
**Status:** Fachlicher Arbeitsstand / Interview, keine Implementierungsfreigabe
**Stand:** 31.10.2026
-Diese Version konsolidiert die Betreiberangaben vom 31.10.2026, die v0.3 und die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert.
+Diese Version konsolidiert die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die danach bestätigten Entscheidungen E-007 bis E-010 und die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
## Dateien
- `00_Prozesslandkarte.md` – Generischer Gesamtprozess, Prozessfamilien und Zuordnung
-- `P01_Buchungseingang_und_Verfuegbarkeit.md` bis `P05_Abschluss_und_Nachbereitung.md` – getrennte Phasengerüste
+- `P01/` bis `P05/` – je ein eigener Unterordner mit dem bisherigen Phasengerüst; weitere Detaildokumente können dort ergänzt werden
- `G00_Gates_und_Uebergaben.md` – übergreifende Gates
- `S00_Supportprozesse.md` und `X00_Sonderprozesse.md` – vorläufige Kataloge
- `E00_Entscheidungsprotokoll.md` – beschlossene Punkte und offene Fragen
**Quellen:** `crystalline-floating-glacier.md`, `UEBERGABE-BUCHUNGSPROZESS.md`, Gesamtprozess v0.3 und die Betreiberpräzisierung vom 31.10.2026. Weitere Fach- und Rechtsprüfung erforderlich.
-**Arbeitsregel:** Nur ausdrücklich beschlossene Punkte als Entscheidung kennzeichnen; Vorschläge als solche markieren. Keine automatischen Änderungen am produktiven System.
+**Arbeitsregel:** Nur ausdrücklich beschlossene Punkte als Entscheidung kennzeichnen; Vorschläge als solche markieren. Jede Datei trägt einen YAML-Header mit `id`, `typ`, `titel`, `status`, `version`. Die Version v0.5 bezeichnet den konsolidierten **Dokumentationsstand**, nicht eine Implementierungsversion. Bestehende Inhalte werden nicht stillschweigend gekürzt. Änderungen an Gitea erfolgen erst nach Abgleich mit dem dortigen Stand. Keine automatischen Änderungen am produktiven System.
--- a/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
+++ b/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
@@ -1,3 +1,4 @@
+
# P01 – Buchungseingang und Verfügbarkeitssicherung
**Status:** Phasengerüst – Detailinterview steht aus.
--- a/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
+++ b/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
@@ -1,3 +1,4 @@
+
# P02 – Konditionen und Buchungsverbindlichkeit
**Status:** wesentliche Geschäftsregeln im Betreiberinterview bestätigt; Detail- und Rechtsprüfung offen.
--- a/P03/P03_Buchungsverwaltung_und_Abwicklung.md
+++ b/P03/P03_Buchungsverwaltung_und_Abwicklung.md
@@ -1,3 +1,4 @@
+
# P03 – Buchungsverwaltung und kaufmännische Abwicklung
**Status:** Phasengerüst; Detailinterview steht aus.
--- a/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
+++ b/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
@@ -1,3 +1,4 @@
+
# P04 – Leistungsvorbereitung und Aufenthalt
**Status:** Phasengerüst; Detailinterview steht aus.
--- a/P05/P05_Abschluss_und_Nachbereitung.md
+++ b/P05/P05_Abschluss_und_Nachbereitung.md
@@ -1,19 +1,20 @@
+
# P05 – Abschluss und Nachbereitung
**Status:** Phasengerüst; Detailinterview steht aus.
## Zweck
-Aufenthalt und Buchung nachvollziehbar abschließen, Feedback einholen und offene Folgeaufgaben kontrolliert weiterführen.
+Buchungs- und Leistungserbringung nachvollziehbar abschließen, Feedback einholen und offene nachlaufende Fälle **kontrolliert an zuständige Folgeprozesse übergeben**, ohne den V01-Hauptprozess deshalb künstlich offen zu halten (E-010).
## Aktivitäten (vorläufig)
- Abreise und Leistungsabschluss dokumentieren.
-- Ausstehende Abrechnung, Erstattungen, Schäden oder Nachforderungen erkennen und behandeln.
+- Ausstehende Abrechnung, Erstattungen, Schäden oder Nachforderungen erkennen, soweit Teil der unmittelbaren Buchungsabwicklung behandeln und sonst mit nachvollziehbarer Zuständigkeit und Buchungsreferenz an einen Folgeprozess übergeben.
- Reinigung/Reparatur/Objektbereitstellung für nächsten Aufenthalt initiieren und Status verfolgen.
- Dankesnachricht, Feedback und Bewertung im **Buchungsprozess V01** abwickeln.
- Zulässige Informationen an den **eigenständigen Wertschöpfungsprozess V02 – Gästebindung/Marketing** übergeben; ggf. Loyalty-Ereignis auslösen.
## Gates
-Fachlicher, finanzieller und objektbezogener Abschluss können unterschiedliche Zustände haben. Das exakte Schließkriterium ist noch zu entscheiden.
+Fachlicher, finanzieller und objektbezogener Abschluss können unterschiedliche Zustände haben. **Grundsatz (E-010):** V01 kann nach erfolgter Buchungs- und Leistungserbringung fachlich abgeschlossen werden, auch wenn übergebene Ansprüche oder Konflikte noch zu bearbeiten sind. Übergaben müssen zugeordnet, nachvollziehbar und mit der Buchung verknüpft bleiben. **Welche Pflichtaktivitäten den V01-Abschluss konkret freigeben, ist noch offen.**
## Noch offen
-Wann Akte abgeschlossen sein darf; Weiterverfolgung offener Forderungen; Objektbereitstellung und Abgrenzung zum Folgeaufenthalt.
+Genaue Abschlusskriterien und erforderliche Nachweise; Zuständigkeit und Verknüpfung nachlaufender Folgeprozesse; Objektbereitstellung und Abgrenzung zum Folgeaufenthalt; alternativer Ausgang bei Stornierung oder abgebrochenem Vorgang. **Ob die technische Buchungsakte geschlossen wird oder nur der V01-Prozessstatus wechselt, ist nicht entschieden.**
@@ -1,193 +0,0 @@
--- v0.5/00_Prozesslandkarte.md
+++ v0.6/00_Prozesslandkarte.md
@@ -3,10 +3,10 @@
typ: prozesslandkarte
titel: FewoPortal – Prozesslandkarte
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
-# 00 – Prozesslandkarte FewoPortal v0.5
+# 00 – Prozesslandkarte FewoPortal v0.6
**Status:** gemeinsamer Arbeitsstand; übergreifendes Modell, nicht vollständig freigegeben.
**Stand:** 31.10.2026
@@ -94,6 +94,8 @@
Ein Sonderprozess kann mehrere Phasen betreffen und verwendet dieselbe Buchungsakte und Ereignishistorie. **Nach abgeschlossenem Buchungs- und Leistungsprozess** können noch offene Ansprüche oder Konflikte als eigenständig zu bearbeitende Folgeprozesse weitergeführt werden; die Referenz auf die ursprüngliche Buchung und der Übergabenachweis bleiben erhalten (E-010).
+**Alternative fachliche Endergebnisse V01 (E-011):** Ein regulär erfüllter Aufenthalt, eine ohne Buchung beendete Anbahnung (z. B. Angebotsablauf oder Ablehnung) und die Stornierung nach entstandener Verbindlichkeit sind unterschiedliche Ergebnisse **desselben** generischen Prozesses. Eine reguläre Leistungserbringung durchläuft typischerweise P05; ein früher Abbruch muss nicht künstlich P03–P05 durchlaufen. Auslösende Ereignisse, Nachweise, ggf. Belegungsfreigabe und verbleibende Folgepflichten werden nachvollziehbar dokumentiert. Weitere Endergebnisse sowie exakte Übergangsbedingungen sind offen.
+
## F. Zentrale Gate-Philosophie
**P05-Abschluss-/Übergabegate (E-010):** Abschluss der Buchungs- und Leistungserbringung ist vom Ende nachlaufender Forderungs-, Schadens- oder Streitfälle zu unterscheiden. Offene Fälle werden mit Kontext, Verantwortlichkeit und Referenz zur Buchung an den jeweils zuständigen Folgeprozess übergeben. Die endgültigen Pflichtkriterien und Zustände werden in P05 spezifiziert.
@@ -104,7 +106,7 @@
1. **Detailkriterien für den fachlichen Abschluss von V01:** Welche Leistungen, Informationen und Übergaben müssen konkret abgeschlossen sein? Die Grundentscheidung ist getroffen: Nachlaufende Forderungen/Schäden blockieren nicht allein den Abschluss der Buchungs- und Leistungserbringung, wenn sie nachvollziehbar an einen verantwortlichen Folgeprozess übergeben wurden (E-010).
2. Detailschnitt der buchungsbezogenen Objektaufgaben zu P04/P05; **keine Entscheidung für ein eigenständiges Objektmanagement-Modul**.
-3. Genauer Status- und Gate-Katalog, insbesondere Synchronisationssicherheit und externe Stornoereignisse.
+3. Genauer Status- und Gate-Katalog, **einschließlich alternativer Prozessausgänge nach E-011**, Synchronisationssicherheit und externer Stornoereignisse.
4. Abgrenzung P03/P04; Relevanz und Nachweisbarkeit der lokalen Prozesse.
5. Pro Kanal tatsächlicher Verbindlichkeitsnachweis, Datenlage und Portalbestimmungen.
--- v0.5/E00_Entscheidungsprotokoll.md
+++ v0.6/E00_Entscheidungsprotokoll.md
@@ -3,7 +3,7 @@
typ: entscheidungsprotokoll
titel: Entscheidungsprotokoll
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
# E00 – Entscheidungsprotokoll
@@ -22,9 +22,10 @@
| **E-008** | Beschlossen / Betreiberpräzisierung | V02 umfasst **Multichannel-Marketing und Gästegewinnung** (eigene Website, Social Media, Print, externe Portale) **sowie CRM, Stammkundenmanagement und Loyalty**. Damit ist V02 nicht nur Folgeprozess, sondern auch vorgelagert. Feedback/Bewertungen bleiben in V01. Detaillierung von V02 folgt später. |
| **E-009** | Beschlossen / Betreiberpräzisierung | Buchungsbezogene Objektaufgaben (Reinigung, Schlüsselübergabe, lokale Leistungen) im Hauptprozess **einfach und integriert** behandeln. Die fachliche Existenz von Supportprozessen bedeutet **keine Pflicht zu eigenen Verwaltungsmodulen**. Erweiterte Objektverwaltung, Dienstleister-/Personalplanung und Vermittlungsagentur-Funktionen derzeit nicht priorisieren; Erweiterbarkeit offenhalten. |
| **E-010** | Grundsatz bestätigt / Details offen | Der Hauptwertschöpfungsprozess V01 endet fachlich mit Abschluss der Buchungs- und Leistungserbringung. Danach weiterlaufende Forderungs-, Schaden- oder Streitfälle sind **an zuständige Folgeprozesse zu übergeben**, anstatt den gesamten Buchungsprozess künstlich offen zu halten. Zusammenhang zur Buchung, Zuständigkeit und Übergabe müssen nachvollziehbar bleiben. Das genaue Abschluss-Gate ist noch zu spezifizieren. |
+| **E-011** | Beschlossen / Detailkriterien offen | V01 kann mit **unterschiedlichen fachlichen Endergebnissen** enden: regulär abgeschlossen (erbrachte Leistung), ohne Buchung beendet (z. B. abgelehnte/abgelaufene Anfrage bzw. nicht angenommenes Angebot) oder storniert (nach entstandener Verbindlichkeit, soweit zutreffend). Diese Ergebnisse sind **alternative Ausgänge eines einzigen generischen Prozesses**, keine zusätzlichen Buchungsworkflows. Nachweise, Historie und erforderliche Folgeaktivitäten/Übergaben bleiben erhalten. Die vollständige Taxonomie und konkrete Zustandsübergänge sind noch zu spezifizieren. |
## Offene Grundsatzentscheidungen
-- Konkrete Mindestkriterien für P05-Abschluss, Übergabenachweis und Zuständigkeit der Folgeprozesse; Umgang mit abgebrochenen oder stornierten Vorgängen.
+- Konkrete Mindestkriterien für P05-Abschluss, Übergabenachweis und Zuständigkeit der Folgeprozesse; **Detailkriterien** und die vollständige Taxonomie der alternativen Prozessausgänge (E-011).
- Detailschnitt der buchungsbezogenen Objektaufgaben zu P04/P05; Umfang späterer buchungsunabhängiger Funktionen.
- Exakter Mindest-Nachweis und Datenumfang je externem Portalprofil.
--- v0.5/G00_Gates_und_Uebergaben.md
+++ v0.6/G00_Gates_und_Uebergaben.md
@@ -3,7 +3,7 @@
typ: gate-modell
titel: Gate- und Übergabemodell
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
# G00 – Gate- und Übergabemodell (Arbeitsstand)
@@ -36,5 +36,8 @@
- **Übergabe:** Benötigt mindestens Referenz zur ursprünglichen Buchung, Beschreibung des offenen Sachverhalts, verantwortliche Stelle und nachweisbaren Übergabestatus. Detailumfang und Automatismus bleiben offen.
- **Status:** Buchungsprozess abgeschlossen und Folgeprozess offen sind gleichzeitig möglich. Die technische Ausgestaltung der Akte ist noch nicht beschlossen.
+## Alternative End-Gates V01 (E-011)
+Je nach tatsächlichem Verlauf weist V01 ein eigenes fachliches Endergebnis aus: **regulär abgeschlossen**, **ohne Buchung beendet** oder **storniert** (nach Verbindlichkeit). End-Gates sichern die jeweils zutreffenden Nachweise und gegebenenfalls erforderliche Folgeübergaben; nicht erforderliche Zwischenphasen werden nicht künstlich ausgeführt. Vollständiger Ergebnis- und Nachweiskatalog bleibt offen.
+
## Noch offen
-Detailkriterien für das P05-Abschlussgate und die Behandlung von Storno-/Abbruch-Ausgängen; konkrete Gatepflichten je Portal; Identität und Nachweisformat; Konflikt- und Synchronisationsfälle; Umfang externer Statusmeldungen; manueller Freigabepunkt.
+Detailkriterien für das P05-Abschlussgate und die Detailbedingungen der Storno-/Abbruch-Ausgänge; konkrete Gatepflichten je Portal; Identität und Nachweisformat; Konflikt- und Synchronisationsfälle; Umfang externer Statusmeldungen; manueller Freigabepunkt.
--- v0.5/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
+++ v0.6/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungseingang und Verfügbarkeitssicherung
status: entwurf
-version: '0.5'
+version: '0.6'
---
# P01 – Buchungseingang und Verfügbarkeitssicherung
--- v0.5/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
+++ v0.6/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Konditionen und Buchungsverbindlichkeit
status: entwurf
-version: '0.5'
+version: '0.6'
---
# P02 – Konditionen und Buchungsverbindlichkeit
--- v0.5/P03/P03_Buchungsverwaltung_und_Abwicklung.md
+++ v0.6/P03/P03_Buchungsverwaltung_und_Abwicklung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungsverwaltung und kaufmännische Abwicklung
status: entwurf
-version: '0.5'
+version: '0.6'
---
# P03 – Buchungsverwaltung und kaufmännische Abwicklung
--- v0.5/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
+++ v0.6/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Leistungsvorbereitung und Aufenthalt
status: entwurf
-version: '0.5'
+version: '0.6'
---
# P04 – Leistungsvorbereitung und Aufenthalt
--- v0.5/P05/P05_Abschluss_und_Nachbereitung.md
+++ v0.6/P05/P05_Abschluss_und_Nachbereitung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Abschluss und Nachbereitung
status: entwurf
-version: '0.5'
+version: '0.6'
---
# P05 – Abschluss und Nachbereitung
@@ -23,5 +23,8 @@
## Gates
Fachlicher, finanzieller und objektbezogener Abschluss können unterschiedliche Zustände haben. **Grundsatz (E-010):** V01 kann nach erfolgter Buchungs- und Leistungserbringung fachlich abgeschlossen werden, auch wenn übergebene Ansprüche oder Konflikte noch zu bearbeiten sind. Übergaben müssen zugeordnet, nachvollziehbar und mit der Buchung verknüpft bleiben. **Welche Pflichtaktivitäten den V01-Abschluss konkret freigeben, ist noch offen.**
+## Abgrenzung zu alternativen Prozessausgängen (E-011)
+P05 beschreibt den regulären Abschluss nach Buchungs- und Leistungserbringung. **Ohne Buchung beendete** Vorgänge (z. B. Angebotsablauf) und **stornierte** verbindliche Buchungen können V01 über andere End-Gates beenden, ohne die regulären P05-Aktivitäten künstlich zu durchlaufen. Offene Folgepflichten und Belege bleiben mit dem ursprünglichen Vorgang verknüpft. Die konkreten Gate- und Nachweiskriterien sind noch offen.
+
## Noch offen
Genaue Abschlusskriterien und erforderliche Nachweise; Zuständigkeit und Verknüpfung nachlaufender Folgeprozesse; Objektbereitstellung und Abgrenzung zum Folgeaufenthalt; alternativer Ausgang bei Stornierung oder abgebrochenem Vorgang. **Ob die technische Buchungsakte geschlossen wird oder nur der V01-Prozessstatus wechselt, ist nicht entschieden.**
--- v0.5/README.md
+++ v0.6/README.md
@@ -3,15 +3,15 @@
typ: projektindex
titel: FewoPortal Prozessarchitektur
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
-# FewoPortal – Prozessarchitektur v0.5
+# FewoPortal – Prozessarchitektur v0.6
**Status:** Fachlicher Arbeitsstand / Interview, keine Implementierungsfreigabe
**Stand:** 31.10.2026
-Diese Version konsolidiert die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die danach bestätigten Entscheidungen E-007 bis E-010 und die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
+Diese Version führt den konsolidierten Stand v0.5 mit **E-011 (alternative fachliche Prozessausgänge)** fort und bewahrt die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die Entscheidungen E-001 bis E-010 sowie die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
## Dateien
--- v0.5/S00_Supportprozesse.md
+++ v0.6/S00_Supportprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Supportprozesse
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
# S00 – Supportprozesse (vorläufiger Katalog)
--- v0.5/X00_Sonderprozesse.md
+++ v0.6/X00_Sonderprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Sonder- und Ausnahmeprozesse
status: arbeitsstand
-version: '0.5'
+version: '0.6'
---
# X00 – Sonder- und Ausnahmeprozesse (vorläufiger Katalog)
@@ -22,6 +22,8 @@
| X08 | Aufenthaltsabweichung | No-show, Verlängerung, vorzeitige Abreise |
| X09 | Schäden/Reklamation | Mangel, Schaden, Kaution/Nachforderung |
+**Alternative Prozessausgänge (E-011):** X03 kann zu **ohne Buchung beendet** führen; X04 kann eine bereits verbindliche Buchung zu **storniert** führen. Dies sind Endergebnisse von V01, keine eigenständigen parallelen Buchungsworkflows. Vorreservierung, Kalender, Dokumentation und offene Pflichten müssen je Fall nachweisbar behandelt werden. Einzelregeln noch offen.
+
**Prozessübergabe nach V01 (E-010):** Nach Abschluss der Buchungs- und Leistungserbringung noch offene Fälle (z. B. Schadenersatzforderung, Erstattung, Streitfall) werden an einen zuständigen Folgeprozess übergeben. Sie bleiben mit der ursprünglichen Buchung verbunden. Ob dafür ein separater Vorgang oder eine verknüpfte Aktivität angelegt wird, ist noch nicht entschieden.
**Rechtsfragen separat:** Für externe Vollabwicklung liegt die Vertrags-/Mahn-/Storno-Verantwortung beim Portal gemäß vertraglicher Vereinbarung; FewoPortal braucht einen nachvollziehbaren Übergabestatus und mindestens die für eigene Pflichten nötigen Informationen.
@@ -1,783 +0,0 @@
--- basis/X00_Sonderprozesse.md
+++ v0.7/X00_Sonderprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Sonder- und Ausnahmeprozesse
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
# X00 – Sonder- und Ausnahmeprozesse (vorläufiger Katalog)
@@ -27,3 +27,10 @@
**Prozessübergabe nach V01 (E-010):** Nach Abschluss der Buchungs- und Leistungserbringung noch offene Fälle (z. B. Schadenersatzforderung, Erstattung, Streitfall) werden an einen zuständigen Folgeprozess übergeben. Sie bleiben mit der ursprünglichen Buchung verbunden. Ob dafür ein separater Vorgang oder eine verknüpfte Aktivität angelegt wird, ist noch nicht entschieden.
**Rechtsfragen separat:** Für externe Vollabwicklung liegt die Vertrags-/Mahn-/Storno-Verantwortung beim Portal gemäß vertraglicher Vereinbarung; FewoPortal braucht einen nachvollziehbaren Übergabestatus und mindestens die für eigene Pflichten nötigen Informationen.
+
+
+## Präzisierung v0.7: Änderungs-/Stornovorgang und Konfliktnachweise
+
+- **X02/X04:** Zwischen *Anfrage*, *Annahme/Bestätigung*, *wirksamer Vertragsänderung/Stornierung* und *tatsächlichen Finanz-/Belegungsfolgen* unterscheiden. Ursache, Initiator, Ausführender und Verantwortlicher sind keine austauschbaren Felder. Tatsächlicher Vermieterstornogrund bleibt Vermieterstornogrund, selbst wenn ein Gast auf der Portaloberfläche die Aktion ausführt; Portalregeln und rechtliche Wirkungen gesondert prüfen. Der Betreiber hat beim FeWo-direkt-Konto bislang keine solche Änderung oder Vermieterstornierung selbst durchgeführt; unbekannte Prozesse nicht als erprobte Ist-Abläufe ausgeben.
+- **X05/X06:** Fehlende Preisdetails, zusammengefasste Service-/Provisionsanteile oder abweichende Auszahlungssummen sind normale Klärungsfälle; manuelle Zuordnung und erneuter Abgleich, ohne Buchungspreis zu überschreiben.
+- **X07:** Bei Destination Solutions manuelle Kalendersperre ohne serverseitig/partnernetzweit bestätigten Sperrnachweis; bei FeWo-direkt verzögerter iCal-Import. Technische Ursache und mögliche Rechts-/Haftungsfolgen getrennt bewerten. [Ausführlicher Fachfall X07](X01_Belegungskonflikte_und_Sperrnachweise.md).
--- basis/AENDERUNGSUEBERSICHT.md
+++ v0.7/AENDERUNGSUEBERSICHT.md
@@ -6,3 +6,14 @@
- Offene Detailkriterien und Zustandsübergänge ausdrücklich **nicht** als entschieden dargestellt.
- Keine Löschung bestehender Inhalte, keine Änderung des Anwendungscodes. Gitea selbst wurde nicht verändert.
- `AENDERUNGEN_ZU_V0.6.diff` dokumentiert die tatsächlichen Textänderungen.
+
+
+# Änderung v0.7 gegenüber v0.6 (Konsolidierung 31.10.2026)
+
+- E-012–E-021 aus dem fachlichen Interview nachgeführt; fünf Archetypen, kein A6.
+- Destination Solutions (A3) als realer Referenzfall samt Stornostaffel, manueller Sperre ohne Übernahmenachweis, provisionsabhängigen Partnerkanälen und ungeklärtem Gast-Aufschlag dokumentiert.
+- FeWo-direkt (A4) um differenzierte Zahlungsdaten, iCal-Risiko, noch offene Rechts-/Gast- und Gebühreninformationen ergänzt.
+- Flexible Preispositionen und Sammelbeträge, manuelle/hybride Klärung und kontrollierbare Nachweiskette in P01–P05, K00/K01, G00, X00 aufgenommen.
+- Neues Portalfragenregister und verbindliche Dokumentationsarbeitsregel: aktuelle Originaldokumente künftig **vor jedem Edit erneut anfordern**.
+- R01-Referenzentwurf inhaltlich unverändert übernommen, R08 neu ergänzt.
+- Ausgangsdokumente unverändert gelassen; Diff und Prüfliste im Paket. Keine Gitea-Änderung/Implementierungsfreigabe.
--- basis/00_Portalprofile_und_Vertragsvorlagen.md
+++ v0.7/00_Portalprofile_und_Vertragsvorlagen.md
@@ -3,10 +3,10 @@
typ: fachliches-konzept
titel: Portalprofile, Konditionsquellen und Vertragsvorlagen
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
prozess: V01
-bezugsstand_archetypen: "0.3"
+bezugsstand_archetypen: "0.6"
---
# K00 – Portalprofile und Vertragsvorlagen
@@ -39,7 +39,7 @@
| A1 / A2, eigener Angebotsabschluss | Eigenes **bindendes Angebot** mit ausgewählten Vertragsbedingungen/Anlagen. Wirksam angenommene Version wird unverändert nachgewiesen; anschließend Vertragsdokument bzw. Bestätigung aus diesem Stand. |
| A3 / A4, extern bereits verbindlich, Vertragstext/Unterlagen durch uns | **Kanal- und buchungstypspezifische Vertragsdokumentation** der bereits vereinbarten Bedingungen; **keine zweite obligatorische Annahme**. Widersprechende/neue Klauseln nicht still ergänzen. |
| A5, Vertrag/Abwicklung extern | Externen Vertrags- und Konditionsnachweis referenzieren/ablegen, eigene Dokumente nur, wenn erforderlich. Keine doppelte Vertragsbegründung. |
-| A6, Hub/Partnervermittlung | Aus Herkunft und tatsächlicher Zuständigkeit das passende A2–A5-Profil und damit Dokumentenprofil bestimmen. |
+| Optional: Partnerherkunft | **Kein eigener Archetyp A6.** Nur bei kaufmännischer Relevanz (z. B. unterschiedliche Vermittlerprovision) Herkunft erfassen; Buchung bleibt A1–A5. |
Eine **gemeinsame Konditions-/Vertragszusammenstellung** soll vor dem Versand anzeigen: maßgeblicher Preis, enthaltene/optionale Leistungen, Rabatte, Stornoregel, Gastdaten, gewählte **Vorlage mit Version**, passende **Anlagen**, nachweisbarer Konditionsstand und Dokumentenvorschau. Der Vermieter kann die Auswahl im Rahmen der rechtlich/fachlich zulässigen Regeln korrigieren; keine separaten Portalfomulare.
@@ -76,3 +76,29 @@
4. **Noch offen:** Welche konkreten Dokumententypen und Anlagen sollen über Vermieter/Objekt/Portal hinweg wiederverwendbar sein, und welche müssen zwingend getrennt bleiben?
**Status:** Portalübergreifende Fachregeln aus dem Interview festgehalten; Auswahlregeln sind ein fachlicher Vorschlag zur späteren Validierung, **keine freigegebene technische Implementierung**.
+
+
+## 8. Erweiterung v0.2 – Flexible Portal- und Preisfunktionen
+
+**Konfiguration nach tatsächlicher Fähigkeit statt Portalname fest in Programmcode:**
+
+| Merkmal | Konfigurierbare Ausprägungen / Konsequenz |
+|---|---|
+| Eingang/Belegung | iCal/API/E-Mail/Portalansicht/manuell; zeitverzögert, nicht verfügbar oder unbekannt; manuelle Sperraufgabe zulässig |
+| Gast-/Vertragsdaten | vollständig, teilweise, nicht geliefert; ggf. manuell über Gast oder Portal abrufen |
+| Vertrag und Preisquelle | eigene verbindliche Angebotsdaten oder extern bestätigter Gastpreis; Gesamtbetrag auch ohne Einzelpreise zulässig |
+| Preisdetailtiefe | Einzelpositionen, Sammelpositionen, reiner Gesamtpreis; Gebührentyp oder Empfänger kann ungeklärt bleiben |
+| Preisaufschlag/Provision | Vermieterprovision, zusätzliche Gast-Servicegebühr, partnerkanalabhängiger Endpreisaufschlag – getrennt, sofern belegbar; auch kombinierte/unbekannte Position zulassen |
+| Zahlungszuständigkeit | Eigener Einzug oder Portal/Paymentanbieter; Ratenstatus, Auszahlungsvorschau und Bankeingang getrennt |
+| Stornobedingungen | Portalkonfiguration, beim Vertragsschluss nachweislich vereinbarter Stand, später übermitteltes eigenes Dokument trennen |
+| Bearbeitungsmodus | automatisch / manuell / gemischt, nach einzelner Aktivität bzw. verfügbarem Feld; offene Klärungsaufgabe statt erfundene Daten |
+| Nachweise | Zeitpunkt der Erfassung, ggf. Screenshot/Buchungsbestätigung, Zeitpunkt und Wirksamkeit einer Kalendersperre soweit nachgewiesen |
+
+**Keine freie Regel-Engine für MVP erforderlich.** Wenige Profilparameter sowie manuelle, nachvollziehbare Bearbeitungsschritte reichen zunächst. Die tatsächliche Informationstiefe kann **von Buchung zu Buchung** variieren, nicht nur pro Portal.
+
+### Konkrete Kanalprofile als gesonderte Referenzfälle
+
+- **FeWo-direkt (A4):** Eigene Miet-/Rabatt-/Stornokonfiguration im Portal; im Vermieterposteingang sind bei einer Buchung einzelne Summen, Zahlungsraten und erwartete Auszahlung ersichtlich, nicht notwendigerweise die Einzelpreiszerlegung. Eigener statischer Mietvertrag bislang nicht im Inserat hinterlegt. Angeblich/öffentlich angebotene Funktionen sind nicht automatisch im konkreten Betreiberkonto vorhanden.
+- **Destination Solutions (A3):** Extern bereits verbindliche Buchung; danach vollständige Abwicklung beim Vermieter. **In aktuellem Betreiberzugang keine Kalendersynchronisation**; manuelle Portalsperrung mit begrenzter Nachweisbarkeit. Provision kann nach Vertriebskanal differieren; Gast-Serviceaufschlag, Preisaufschläge und vorvertragliche Anzeige der Stornobedingungen sind noch ungeklärt.
+
+Details: [K01 Preise & Abrechnung](K01_Preisstruktur_und_Abrechnung.md); [R08 Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md); [O00 offene Fragen](O00_Offene_Portalprueffaelle.md).
--- basis/S00_Supportprozesse.md
+++ v0.7/S00_Supportprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Supportprozesse
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
# S00 – Supportprozesse (vorläufiger Katalog)
@@ -25,3 +25,11 @@
**Einordnung für den heutigen Produktumfang:** S01–S07 und S09 soweit für Buchungsabwicklung nötig; S08 schlank in P04/P05. V02-Marketing und Loyalty sind **Wertschöpfung** und nicht bloß allgemeine administrative Supportprozesse. Marketingfunktionen werden fachlich vorgesehen, aber nach dem Kernbuchungsprozess detailliert.
Einzelheiten folgen nach Freigabe der Gesamtprozesslandkarte. Keine zusätzlichen Organisations-/Oberflächenmodule aus dieser Tabelle ableiten.
+
+
+## Präzisierung v0.7 (E-012 bis E-020)
+
+- **S01:** Portalprofil umfasst tatsächliche Datenschnittstelle (oder manuelle Schritte), Ausführungsverantwortung, Quellennachweis, Preis-/Storno-Verfügbarkeit und den Status nachgelagerter Vertriebskanäle, soweit relevant. Partnerherkunft ist **kein A6-Prozess**; nur kaufmännisches Merkmal bei Bedarf.
+- **S02:** Kalenderverzögerung, manuelle Sperrung und fehlender Bestätigungsbeleg als reale Normalfälle. „Exportiert“ oder „im Portal eingetragen“ ist nicht gleich „partnernetzweit wirksam“.
+- **S04/S07:** Kaufmännische **Einzel-, Sammel- und Gesamtbeträge** unterstützen; Gast-Servicegebühr, Vermieterprovision, Preisaufschlag, Rabatte, Zahlung und Auszahlung getrennt, soweit feststellbar. Unbekannte Zusammenhänge bleiben ungeklärt; manueller Abgleich möglich.
+- **S05/S06:** unterschiedliche Vertragsvorlagen/Anlagen und Versionen je Buchungsprofil; manuelle Daten-/Dokumentenbeschaffung und Klärungsaufgaben ohne separate Portalsoftware-Workflows.
--- basis/G00_Gates_und_Uebergaben.md
+++ v0.7/G00_Gates_und_Uebergaben.md
@@ -3,7 +3,7 @@
typ: gate-modell
titel: Gate- und Übergabemodell
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
# G00 – Gate- und Übergabemodell (Arbeitsstand)
@@ -41,3 +41,14 @@
## Noch offen
Detailkriterien für das P05-Abschlussgate und die Detailbedingungen der Storno-/Abbruch-Ausgänge; konkrete Gatepflichten je Portal; Identität und Nachweisformat; Konflikt- und Synchronisationsfälle; Umfang externer Statusmeldungen; manueller Freigabepunkt.
+
+
+## Ergänzende Gates / Informationsbewertung v0.7 (E-013 bis E-020)
+
+- **G1/P01 – Externe Belegung:** Zeitpunkt und Quelle von Kalenderexport, manueller Sperre oder Meldung dokumentieren. **Veranlasst**, **im Zielportal beobachtet** und **in nachgelagerten Kanälen nachgewiesen** sind verschiedene Zustände; letzterer kann unbekannt bleiben.
+- **G2/P02 – Konditionsstand:** Extern verbindlicher **Gastgesamt-/Mietpreis** kann hinreichend belegt sein, auch wenn Tages-/Einzelpreise fehlen. Portalkonfiguration, Buchungssnapshot, gastseitig tatsächlich vereinbarter Konditionsstand und nachträglich versandte Unterlagen getrennt. Fehlt ein für Vertragsdokumentation erforderlicher Beleg, nur die konkrete Tätigkeit zur Klärung vorsehen; bereits bindende Buchung nicht rückwirkend entwerten.
+- **G3/P03 – Kaufmännische Teilinformationen:** Einzelposition, Sammelposten und Gesamtbetrag zulässig; Quelle, Betrag, Währung, zugeordneter Zahler/Empfänger (oder **ungeklärt**), Status und mögliche Doppelzählung prüfen. Gast-Mietforderung ≠ Gast-Portalservicegebühr ≠ Vermieterprovision ≠ Auszahlung. Aufklärung je Tätigkeit; fehlende Provisionsdetails blockieren beispielsweise nicht automatisch die Anreisevorbereitung.
+- **G3/P03 – Zahlung:** **Fällig laut Zahlungsplan**, **laut Portal bezahlt**, **Auszahlung angekündigt** und **tatsächlicher Bankeingang** sind unabhängige Status. Widersprüchliche Portalwerte bleiben offen, nicht automatisch überschrieben.
+- **X02/X04/X07:** Storno-/Änderungsantrag ist **kein** wirksames Ergebnis. Bei Belegungskonflikt Ursache, zeitliche Abfolge, Bindung beider Buchungen, belegte extern wirksame Sperren und verbleibende Handlungsmöglichkeiten erfassen; Verantwortlichkeit wird nicht aus einem einzigen Button abgeleitet.
+
+**Evidenzstatus je Datenpunkt:** `übermittelt / durch externe Quelle behauptet / anhand Beleg geprüft / intern erfasst / manuell ergänzt / nicht geliefert / widersprüchlich / nicht anwendbar`; als **fachliche Beispiele**, nicht als freigegebene technische Enum. `unbekannt` ist **nicht** `0` oder `nicht vorhanden`.
--- basis/E00_Entscheidungsprotokoll.md
+++ v0.7/E00_Entscheidungsprotokoll.md
@@ -3,7 +3,7 @@
typ: entscheidungsprotokoll
titel: Entscheidungsprotokoll
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
# E00 – Entscheidungsprotokoll
@@ -40,3 +40,25 @@
## Dokumentationsregel (Arbeitsvereinbarung)
Die bestehende Gitea-Dokumentation ist die führende Ablage. Es gibt **eine aktuelle Markdown-Datei je Thema**, P01–P05 dürfen jeweils mehrere Unterdokumente enthalten. Bei **neuen und fachlich aktualisierten Markdown-Dateien** einen knappen YAML-Header (`id`, `typ`, `titel`, `status`, `version`) verwenden. Bestehende Abschnitte bei Fortschreibungen nicht still kürzen oder löschen; fachliche Entscheidungen mit ID verknüpfen und Änderungen per Git-Diff kontrollieren. **Keine implizite Freigabe von Implementierung oder Go-live.**
+
+
+## Ergänzende Beschlüsse und Prüfstände vom 31.10.2026 – Konsolidierung v0.7
+
+Die folgenden IDs ergänzen **E-001–E-011**. Betreiberangaben und die daraus fachlich bestätigten Regeln sind von ausstehenden Portal- und Rechtsprüfungen zu unterscheiden.
+
+| ID | Status | Festlegung |
+|---|---|---|
+| **E-012** | **Beschlossen** | **Genau fünf Buchungsarchetypen A1–A5**. Der zuvor verwendete A6-Eintrag („Hub/Partnervermittlung“) entfällt als Archetyp. Partnerherkunft ist nur als optionales kaufmännisches Merkmal zu erfassen, soweit sie etwa Provisionssatz oder Auswertungen beeinflusst; keine eigenständige Vermittlungskettenlogik. |
+| **E-013** | **Beschlossen** | **Vertrags-/Dokumentenprofil je Vermieter/Objekt/Portal/Buchungsart**, inklusive unterschiedlicher Vorlagen und Anlagen, Versionierung und unverändertem Buchungs-/Konditionsstand. Nach externer Direktbuchung **keine zweite Annahme und keine einseitigen neuen Gastpflichten**. Die tatsächliche vorvertragliche Einbeziehung bleibt Prüffall. |
+| **E-014** | **Beschlossen** | Die Informationsbeschaffung kann je Portal und Feld **automatisch, manuell oder gemischt** erfolgen. Fehlen Einzelbeträge, dürfen Buchungen mit **Gesamtpreis oder Sammelpositionen** bearbeitet werden; fehlende Daten sind ausdrücklich unbekannt, nicht null und nicht geschätzt. |
+| **E-015** | **Beschlossen** | **Gast-Mietforderung, ggf. gesonderte Gast-Servicegebühr, Vermieterprovision/-gebühr, Zahlungsraten, Auszahlung und Rabatte** sind fachlich getrennte Sachverhalte, auch wenn ein Portal Beträge zusammenfasst. Flexible kaufmännische Positionen, spätere manuelle Zuordnung/Aufteilung, Nachweis und Differenzabgleich sind erforderlich; ursprüngliche Portalwerte bleiben erhalten. **Keine doppelte Zählung** zusammengefasster Teil- und Gesamtbeträge. |
+| **E-016** | **Beschlossen / Referenzbetrieb** | **Destination Solutions = A3**, keine Ergänzung „A6“: bereits extern verbindliche Buchung, nachfolgende Vertrags-/Zahlungs-/Aufenthaltsabwicklung durch Vermieter. Partnerherkunft kann unterschiedliche **Vermittlerprovisionen zu Lasten des Vermieters** bewirken, aber **keine nachträgliche Belastung des Gastes**. Ob das Portal selbst eine zusätzliche Gastgebühr erhebt oder den Endpreis erhöht, bleibt ungeklärt. |
+| **E-017** | **Bestätigte Betreiberangabe, Wirksamkeit ungeklärt** | Bei Destination Solutions ist folgende **sechsstufige Stornostaffel** genannt: mindestens 60 Tage vorher 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, 11 Tage oder weniger 100 % jeweils vom „Mietpreis“. **Nicht nachgewiesen** ist, ob diese Staffel im Portal bereits vor Buchung transparent gemacht und wirksam einbezogen wird; die Preisbasis („Mietpreis“) ist zu klären. |
+| **E-018** | **Beschlossen / Risiko festgehalten** | **Externe Verfügbarkeit ist nicht allein durch korrekte Pflege des FewoPortal-Kalenders sicher**: FeWo-direkt importiert iCal nur zeitverzögert; beim verwendeten Destination-Solutions-Zugang erfolgt **manuelle Sperrung ohne bestätigtes Partnernetz-Sync und ohne verwertbaren Sperrbeleg**. Vorgang „Sperre veranlasst / Zielportal erkennbar / partnernetzweit wirksam“ getrennt; letzteren Zustand niemals ohne Nachweis behaupten. |
+| **E-019** | **Beschlossen** | Buchungsänderung, Storno und Doppelbuchung sind **Teil-/Sonderprozesse derselben Akte**. Auslösende Ursache, Initiator, ausführender Akteur, Zuständigkeit, verbindliche Wirksamkeit sowie Kalender-/Vertrags-/Finanzfolgen getrennt führen. Technische Stornierung durch den Gast ersetzt nicht die wahrheitsgemäße Einordnung einer Vermieterursache; Fremdportalregelungen und Rechtslage fallbezogen prüfen. |
+| **E-020** | **Beobachteter A4-Iststand** | In einer FeWo-direkt-Buchung sind **aggregierter Übernachtungspreis, Rabatt, Sammelgebühren, Gastgesamtbetrag, portalbezogener Abzug, Auszahlungsvorschau und Ratenstatus** einsehbar. **Nicht belegt** sind Einzelpreise, Gebührenzusammensetzung, durchgängige Exporte und alle tatsächlich vom Gast akzeptierten Unterlagen. Widersprüchliche Auszahlungsangaben bleiben offener Prüffall. |
+| **E-021** | **Verbindliche Dokumentationsarbeitsregel** | **Vor jeder künftigen Dokumentänderung/Erweiterung die aktuell gültigen Originaldateien erneut explizit beim Betreiber anfordern**. Gitea bleibt führende Ablage; ältere lokale Chat-/ZIP-Kopien allein reichen für spätere Änderungen nicht. Änderungen ausschließlich auf bestätigter Basis, mit Versionsfortschreibung, Bestandsbewahrung, Diff und Quellvermerk. |
+
+**Nicht beschlossen:** Dass technische Portalprobleme automatisch rechtlich fehlendes Verschulden beweisen; dass eine 10-Minuten-Freigabe heute bei den genannten Portalen möglich ist; dass alle Portale gleiche Preis-/Gast-/Zahlungsdaten bereitstellen; dass nachträglich versandte Stornobedingungen wirksam werden. Solche Aussagen bleiben Prüffälle.
+
+**Weitere Fachkonzepte:** [Archetypen A1–A5](00_Buchungsarchetypen.md), [Portal-/Vertragsprofile](00_Portalprofile_und_Vertragsvorlagen.md), [Flexible kaufmännische Positionen](K01_Preisstruktur_und_Abrechnung.md), [Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md), [offene Portalprüffälle](O00_Offene_Portalprueffaelle.md).
--- basis/00_Buchungsarchetypen.md
+++ v0.7/00_Buchungsarchetypen.md
@@ -3,15 +3,15 @@
typ: archetypenkatalog
titel: FewoPortal – Buchungsarchetypen und Verantwortungsübergaben
status: diskussionsentwurf
-version: "0.5"
+version: "0.6"
stand: 2026-10-31
prozess: V01
-bezugsstand_prozessarchitektur: "0.6"
+bezugsstand_prozessarchitektur: "0.7"
---
# A00 – Buchungsarchetypen und Verantwortungsübergaben
-> **Arbeitsstand für das Fachinterview, nicht abschließend freigegeben.** Grundlage: Betreiberbeschreibung vom 31.10.2026; Übergaben `UEBERGABE-BUCHUNGSPROZESS.md` (30.10.2026) und `crystalline-floating-glacier.md` (31.10.2026); Prozessarchitektur v0.6 und Szenario R01. **Bestätigte Geschäftsregeln, aktueller Praxisablauf, Annahmen und offene Fragen werden getrennt ausgewiesen.**
+> **Arbeitsstand für das Fachinterview, nicht abschließend freigegeben.** Grundlage: Betreiberbeschreibung vom 31.10.2026; Übergaben `UEBERGABE-BUCHUNGSPROZESS.md` (30.10.2026) und `crystalline-floating-glacier.md` (31.10.2026); Prozessarchitektur v0.7 und Szenarien R01/R08. **Bestätigte Geschäftsregeln, aktueller Praxisablauf, Annahmen und offene Fragen werden getrennt ausgewiesen.**
## 1. Gemeinsamer Grundsatz
@@ -25,7 +25,7 @@
**Archetypen sind Geschäftskonstellationen, keine getrennt zu implementierenden Workflows.** Sie bestimmen die bei Eintritt bekannten Tatsachen, Zuständigkeiten, notwendigen Aktivitäten, Kommunikationswege und Nachweise. Dieselbe Buchungsakte und dieselben Fachfunktionen werden verwendet. Ein Portal kann einzelne Tätigkeiten durchführen; FewoPortal behält den konsolidierten Vorgangsüberblick, ohne fremde Primärnachweise vorzutäuschen.
-## 2. Katalog der sechs Archetypen
+## 2. Katalog der fünf Archetypen
| ID | Geschäftskonstellation | Zustand beim Eingang | Vertragsunterlagen | Zahlung / Storno | Informationsbedarf |
|---|---|---|---|---|---|
@@ -34,9 +34,8 @@
| **A3** | Externe Direktbuchung mit anschließender vollständiger Abwicklung durch uns | Bereits verbindliche Portalbuchung | Wir versenden Dokumentation der bestehenden Vereinbarung, **keine zweite Annahme** | Wir | Buchung, Portalpreis und Gastdaten übernehmen / ergänzen |
| **A4** | Externe Direktbuchung mit **geteilter Abwicklung** (heutiger FeWo-direkt-Fall) | Bereits verbindliche Portalbuchung | Vertragsdokumentation durch uns ohne zweite Annahme | Zahlung über Portal; tatsächliche Storno-/Mahnverantwortung noch prüfen | Gastdaten, rechtsrelevante Konditionen, Portalstatus, lokale Abgaben |
| **A5** | Externe Direktbuchung mit weitgehend vollständiger Portalabwicklung | Bereits verbindliche Portalbuchung | Durch Portal, soweit tatsächlich vereinbart | Durch Portal, soweit tatsächlich vereinbart | Für Vor-Ort-Betreuung und rechtliche Pflichten benötigte Daten und Status |
-| **A6** | Portal / Buchungshub vermittelt über weitere Partnerportale | Abhängig vom zugrunde liegenden A2–A5 | Abhängig von Herkunft und Abwicklungsmodell | Abhängig von Herkunft und Abwicklungsmodell | **Eingangskanal**, **tatsächliche Herkunft** und **Abwicklungsverantwortung** getrennt erfassen |
-**Modellierungshinweis:** A6 ist ein **zusätzliches Herkunfts- und Vermittlungsmerkmal**, kein eigener alternativer Lebenszyklus. „Manuell/telefonisch“ ist ein **Eingangskanal** und kann insbesondere bei A1/A2 verwendet werden. Eine reine Eigenbelegung/Sperrzeit ist ein angrenzender Belegungsfall, **kein siebter Buchungsarchetyp**.
+**Modellierungshinweis (E-012):** Die ehemalige Kennung **A6 wurde ausdrücklich gestrichen**; Partnervertrieb ist allenfalls ein optionales kaufmännisches Herkunftsmerkmal. „Manuell/telefonisch“ ist ein **Eingangskanal** und kann insbesondere bei A1/A2 verwendet werden. Eine reine Eigenbelegung/Sperrzeit ist ein angrenzender Belegungsfall, **kein weiterer Buchungsarchetyp**.
## 3. Gegenüberstellung entlang des generischen Prozesses
@@ -48,7 +47,7 @@
| **P04 Leistung** | Anreise, lokale Pflichten, Aufenthalt, Abreise | Wie A1 | Wie A1 | Wie A1, zuvor Gastinformationen nachfordern | Wie A1, soweit wir vor Ort verantwortlich sind |
| **P05 Abschluss** | Aufenthalt, Feedback, offene Fälle übergeben | Wie A1 | Wie A1 | Wie A1, ggf. offener Portal-Auszahlungs-/Stornofall | Lokale Erfüllung abschließen, relevante Portal-Ergebnisse erfassen |
-**A6** wird auf die zutreffende Spalte gelegt; die Herkunft kann Konditionen, Pflichten und Kommunikationswege beeinflussen. Phasen können sich zeitlich überlappen; eine bereits extern verbindliche Buchung darf nicht durch offene Stammdaten künstlich unverbindlich werden.
+Die Partnerherkunft begründet **keinen sechsten Archetyp**; sie wird nur bei relevantem Einfluss auf die Vermittlerprovision oder notwendige Auswertung erfasst. Phasen können sich zeitlich überlappen; eine bereits extern verbindliche Buchung darf nicht durch offene Stammdaten künstlich unverbindlich werden.
## 4. Gemeinsame Informations- und Übergabegates
@@ -121,7 +120,7 @@
Die vom Betreiber bereitgestellte vierseitige FeWo-direkt-Vertragsvorlage wurde unter [A04 – Vertragsvorlage und Prozessanalyse](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md) gesondert bewertet. Besonders prüfbedürftig sind: Verbindlichkeit vor dem nachträglichen Vertragsversand (§ 5), zuvor einbezogene Konditionen, Preis-/Gebührentrennung (§ 4), Portalstorno gegenüber eigener Stornoklausel (§ 13), Datenbedarf sowie sichere Trennung von Vertragsdokument und Zugangs-/Anreiseinformationen. **Keine Änderung der Betreibervertragsklauseln ohne gesonderte rechtliche und fachliche Freigabe.**
-**Status dieses Dokuments:** Sechs Betreiber-Archetypen strukturiert, aber nicht als vollständige oder rechtlich validierte Portalprofile freigegeben. Nächster Fachschritt: **A4 als vollständigen Ist-/Soll-Ablauf durchspielen**, einschließlich Vertrag, Zahlung, Gastdaten und Storno; anschließend A3 und A5 dagegenlegen.
+**Status dieses Dokuments:** Fünf Archetypen (A1–A5) nach E-012; Portalprofile und rechtliche Detailfragen bleiben offen. Neben FeWo-direkt (A4) ist Destination Solutions (A3) dokumentierter Praxisfall.
## 10. A4-Praxisnachweis aus FeWo-direkt-Ansichten (31.10.2026)
@@ -130,6 +129,20 @@
**Portalinvariante:** Verantwortlichkeit für Zahlung oder Kommunikation, Portalstatus und tatsächlicher Erfüllungsnachweis sind getrennt zu verwalten.
-## 9. Änderungs- und Stornoereignisse (portalunabhängig)
+## 11. Änderungs- und Stornoereignisse (portalunabhängig)
Ein Storno bzw. eine Buchungsänderung ist ein **Teilprozess auf derselben Buchungsakte**, kein zusätzlicher Archetyp. Die fachliche Ursache (Gastwunsch, Unmöglichkeit beim Vermieter, Doppelbuchung, Regelverstoß, technischer Fehler), der Initiator, der ausführende Beteiligte und die Abwicklungsverantwortung sind voneinander zu unterscheiden. Anfrage, Bestätigung und tatsächliche Wirksamkeit sind getrennte Ereigniszustände. Kalender, Konditionen, Vertrag und Zahlungen werden erst nach ausreichend belegter Wirksamkeit angepasst. Eine durch den Vermieter verursachte Stornierung darf nicht durch Aufforderung an den Gast als Gaststorno umetikettiert werden. **FeWo-direkt** ist dafür ein dokumentiertes Portalbeispiel (siehe [A04 Abschnitt 8](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md)); andere Portale können abweichende Wege, Daten und Zuständigkeiten haben.
+
+
+## 12. Destination Solutions als Praxisreferenz A3 (E-012/E-016/E-017/E-018)
+
+- **Verbindlicher Buchungseingang**, vollständige weitere Vertrags-, Gäste-, Zahlungs- und Aufenthaltsabwicklung beim Vermieter; keine zweite Angebotsannahme. Der Vermieter erhält laut Betreiber eine vollständige Buchungsmeldung für seine Abwicklung, **nicht zwingend eine vollständige Einzelpreis- oder Gebührenzerlegung**.
+- **Keine im genutzten Zugang funktionierende automatische Kalendersynchronisation**; manuelles Blockieren anderer Portale. Ein Portalbeleg über den Zeitpunkt oder die wirksame Verteilung an Partnerkanäle steht nach Betreibererfahrung nicht zur Verfügung.
+- **Vermittlerprovisionen** können nach Vertriebskanal variieren. Sie sind nicht nachträglich vom Gast zu fordern. Ob zusätzlich ein direkter Gast-Aufschlag/Serviceentgelt oder Partner-Endpreisaufschlag existiert, muss beim Anbieter und anhand einer Gastbestätigung geprüft werden.
+- **Stornostaffel** vom Betreiber angegeben: ≥60 Tage 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, ≤11 Tage 100 % vom „Mietpreis“; **vorvertragliche Einbeziehung, Berechnungsbasis und rechtliche Wirksamkeit offen**.
+
+Siehe [R08 Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md) und [O00 Offene Portalprüffälle](O00_Offene_Portalprueffaelle.md).
+
+## 13. Portaldaten können unterschiedlich detailliert und zusammengesetzt sein (E-014/E-015)
+
+Bei A2–A5 sind **automatische, manuelle und hybride** Informationen und Tätigkeiten gleichwertig zu modellieren. Pro Buchung sind vollständig aufgeschlüsselte Positionen, **kombinierte Service-/Gebührenpositionen**, bloße Gesamtbeträge sowie nur teilweise verfügbare Zahlungsauszüge möglich. Keine fiktive Zerlegung des Gesamtpreises; unbekannte Gebührenarten, Zahlende/Empfänger und Provisionsanteile bleiben offen. Nachträgliche Zuordnung oder Aufteilung erhält den originalen Portalbetrag und verhindert doppelte Summierung. Fehlende rein interne Kostenanalyse blockiert nicht ohne Weiteres den vertraglichen Aufenthalt. Siehe [K01](K01_Preisstruktur_und_Abrechnung.md).
--- basis/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md
+++ v0.7/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md
@@ -3,7 +3,7 @@
typ: prozessanalyse
titel: FeWo-direkt – Vertragsvorlage und Einordnung in den A4-Istprozess
status: diskussionsentwurf
-version: "0.4"
+version: "0.5"
stand: 2026-10-31
prozess: V01
archetyp: A4
@@ -157,3 +157,14 @@
- https://hilfe.fewo-direkt.de/articles/Accept-or-decline-a-guest-s-change-request
- https://hilfe.fewo-direkt.de/articles/Die-Reservierung-eines-Gastes-stornieren
- https://www.fewo-direkt.de/tlp/trust-and-safety/partner-initiated-cancellation-policy
+
+
+## 9. Einordnung nach Gesamt-Konsolidierung v0.7
+
+1. **A4 bleibt realer Praxisfall**, nicht Muster für alle Portale. FeWo-direkt zeigt in einer Buchung im Posteingang Zahlungsplan, einige aggregierte Preisbestandteile, Gäste-Gesamtzahlung, Abzug und erwartete Auszahlung; eine lückenlose Einzelpreis-/Gebührentransparenz und eine konsistente Auszahlungsübersicht sind weiter **nicht nachgewiesen**. Das frühere pauschale Urteil „keinerlei Zahlungsdaten“ ist überholt; konkrete Screenshots in Abschnitt 7 sind maßgeblich.
+2. **Ical-Verzögerung:** Direkte Buchung kann vor Verarbeitung einer anderswo veranlassten Blockierung verbindlich werden. FewoPortal darf eigene erfolgreiche Exporte nicht als Portal- oder Partnernetzbestätigung behandeln. Die Idee eines 10-Minuten-Freigabefensters ist **kein aktuell verfügbarer A4-Prozess**.
+3. **Vertragsdokumente:** Der eigene vierseitige Vertrag wird bisher nach der Portalbuchung versandt und ist nicht als statisches PDF in FeWo-direkt hinterlegt; Inhalt der dem Gast vor/bei Buchung gezeigten Bedingungen bleibt zu verifizieren. Statische allgemeine Bedingungen von individuellen Preis-/Zahlungsdetails trennen; keine still nachgeschobenen Verpflichtungen.
+4. **Sonderprozesse:** Bisher keine konkret selbst durchlaufene FeWo-direkt-Buchungsänderung und keine eigene Vermieterstornierung. Kein nicht erprobtes Verfahren als gelebte Praxis behaupten. Differenzierung **tatsächliche Stornoursache, Antragsteller, ausführender Beteiligter** beachten.
+5. **Abrechnung:** Unbekannte Gast-Servicegebühren, Portalabzüge, Vermieterprovisionen oder kombinierte Sammelpositionen müssen nicht künstlich zerlegt werden. Portalinformationen und manuelle Ergänzungen mit Quelle sichern; bei abweichenden Summen Klärungsaufgabe.
+
+Fachliche Konkretisierung: [K01](K01_Preisstruktur_und_Abrechnung.md), [X01](X01_Belegungskonflikte_und_Sperrnachweise.md) und [O00](O00_Offene_Portalprueffaelle.md). Keine Aktualisierung oder juristische Freigabe des ursprünglichen PDF-Vertrags durch diese Analyse.
--- basis/README.md
+++ v0.7/README.md
@@ -3,15 +3,15 @@
typ: projektindex
titel: FewoPortal Prozessarchitektur
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
-# FewoPortal – Prozessarchitektur v0.6
+# FewoPortal – Prozessarchitektur v0.7
**Status:** Fachlicher Arbeitsstand / Interview, keine Implementierungsfreigabe
**Stand:** 31.10.2026
-Diese Version führt den konsolidierten Stand v0.5 mit **E-011 (alternative fachliche Prozessausgänge)** fort und bewahrt die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die Entscheidungen E-001 bis E-010 sowie die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
+Diese Konsolidierung führt die Version v0.6 mit **E-011 (alternative fachliche Prozessausgänge)** fort und bewahrt die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die Entscheidungen E-001 bis E-010 sowie die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
## Dateien
@@ -24,3 +24,25 @@
**Quellen:** `crystalline-floating-glacier.md`, `UEBERGABE-BUCHUNGSPROZESS.md`, Gesamtprozess v0.3 und die Betreiberpräzisierung vom 31.10.2026. Weitere Fach- und Rechtsprüfung erforderlich.
**Arbeitsregel:** Nur ausdrücklich beschlossene Punkte als Entscheidung kennzeichnen; Vorschläge als solche markieren. Jede Datei trägt einen YAML-Header mit `id`, `typ`, `titel`, `status`, `version`. Die Version v0.5 bezeichnet den konsolidierten **Dokumentationsstand**, nicht eine Implementierungsversion. Bestehende Inhalte werden nicht stillschweigend gekürzt. Änderungen an Gitea erfolgen erst nach Abgleich mit dem dortigen Stand. Keine automatischen Änderungen am produktiven System.
+
+
+## Konsolidierung v0.7 (31.10.2026)
+
+**Wichtige Entscheidung E-012:** Fünf Buchungsarchetypen **A1–A5**, **A6 gestrichen**. Referenzportale: Destination Solutions = **A3**, FeWo-direkt = **A4**. Ein generischer V01-Buchungsprozess mit variabler Aktivitäts- und Informationslage; keine separaten Portalworkflows.
+
+**Neue Anforderungen:** Portal-/Dokumentenprofile, versionierter Vertrags-/Konditionsnachweis, manuelle/automatische/gemischte Datenbeschaffung, flexible Einzel- und Sammelpreise, unbekannte Gastgebühr/Provision ohne Scheingenauigkeit, Abstimmung Zahlungsplan vs. tatsächliche Auszahlung, unsichere Kalender-/Sperrnachweise und Änderungs-/Stornoteilprozesse. Externe Direktbuchungen werden nicht durch neues Eigenangebot ersetzt. Rechtlich ungeklärte Portal- und Stornokonditionen bleiben offene Prüffälle.
+
+**Neue bzw. fortgeschriebene Dateien:**
+
+- [`00_Buchungsarchetypen.md`](00_Buchungsarchetypen.md) – A1–A5 und reale Referenzfälle
+- [`00_Portalprofile_und_Vertragsvorlagen.md`](00_Portalprofile_und_Vertragsvorlagen.md) – Profile und Vertragstypen
+- [`K01_Preisstruktur_und_Abrechnung.md`](K01_Preisstruktur_und_Abrechnung.md) – Einzel-/Sammel-/Gesamtbeträge, Provisionen, Zahlungsfluss
+- [`A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md`](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md) – konkrete A4-Beobachtungen und rechtliche Prüffragen
+- [`R00_Szenarien/R01_Eigene_Webseite.md`](R00_Szenarien/R01_Eigene_Webseite.md) – früherer Referenzentwurf, **inhaltlich unverändert**
+- [`R00_Szenarien/R08_Destination_Solutions.md`](R00_Szenarien/R08_Destination_Solutions.md) – A3 Referenzfall
+- [`X01_Belegungskonflikte_und_Sperrnachweise.md`](X01_Belegungskonflikte_und_Sperrnachweise.md) – X07-Vertiefung
+- [`O00_Offene_Portalprueffaelle.md`](O00_Offene_Portalprueffaelle.md) – spätere Konfigurations- und Nachweispunkte
+- [`D00_Dokumentationsregel_und_Uebergabe.md`](D00_Dokumentationsregel_und_Uebergabe.md) – **Pflicht zur erneuten Dokumentenanforderung vor jedem zukünftigen Edit**
+- [`E00_Entscheidungsprotokoll.md`](E00_Entscheidungsprotokoll.md) – Beschlüsse E-012–E-021
+
+**Quellenintegrität:** v0.6 aus dem originalen ZIP extrahiert, da die entpackte v0.6-Verzeichnisansicht P01–P05 nicht enthielt; ergänzende Dokumente aus ihrem jeweils neuesten im Chat verfügbaren Bearbeitungsstand. **Kein direkter Schreibzugriff auf Gitea; keine Repository-Aktualisierung behauptet.** Vor jeder künftigen Änderung aktuelle Quelldokumente erneut vom Betreiber anfordern.
--- basis/00_Prozesslandkarte.md
+++ v0.7/00_Prozesslandkarte.md
@@ -3,10 +3,10 @@
typ: prozesslandkarte
titel: FewoPortal – Prozesslandkarte
status: arbeitsstand
-version: '0.6'
+version: '0.7'
---
-# 00 – Prozesslandkarte FewoPortal v0.6
+# 00 – Prozesslandkarte FewoPortal v0.7
**Status:** gemeinsamer Arbeitsstand; übergreifendes Modell, nicht vollständig freigegeben.
**Stand:** 31.10.2026
@@ -111,3 +111,18 @@
5. Pro Kanal tatsächlicher Verbindlichkeitsnachweis, Datenlage und Portalbestimmungen.
Die detaillierte Umsetzung erfolgt erst nach Abstimmung der Prozesslandkarte.
+
+
+## H. Konkretisierung v0.7: Portalneutralität, Informationslücken und Verantwortlichkeit
+
+**A1–A5 (E-012):** Nur die tatsächliche Buchungs- und Abwicklungsverantwortung klassifiziert den Archetyp. Der bisherige A6-Eintrag entfällt; Herkunft/Partnervertrieb ist bei Bedarf eine separate **kaufmännische Metainformation**, keine eigene Prozessvariante. Referenzfälle: **FeWo-direkt A4**, **Destination Solutions A3**. Der identische V01-Prozess durchläuft dieselben fachlichen Phasen/Gates, Aktivitäten können je Profil extern/intern oder manuell/automatisch erfolgen.
+
+**Fünf unabhängige Dimensionen je Buchung:** (1) rechtlicher Bindungs-/Konditionsnachweis, (2) operative Zuständigkeit, (3) technische Datenquelle/Übermittlungsweg und Verfügbarkeit, (4) preisliche Detailtiefe bzw. Zuordnungsgrad, (5) tatsächliche Nachweisqualität. Aus „Portal zuständig“ folgt weder „erledigt“ noch „nachgewiesen“.
+
+**Kaufmännischer Grundsatz (E-014/E-015):** Das Portal kann Einzelposten, Teilaggregationen, Gesamtpreise, unbekannte Gebührenmischungen oder widersprüchliche Auszahlungsansichten liefern. FewoPortal darf den verbindlichen Gastpreis bei externer Buchung nicht durch Eigenkalkulation ersetzen, keine unbekannten Einzelposten erfinden und keine Vermittlerprovision ohne Vereinbarung dem Gast nachberechnen. Eine manuelle Klärung kann ergänzen; ursprüngliche Rohdaten bleiben erhalten.
+
+**Verfügbarkeit (E-018):** Keine generelle Aussage, dass alle Vertriebskanäle synchron oder endgültig gesperrt sind. Manuell oder zeitversetzt übertragenes Blockieren ist kein Nachweis partnernetzweiter Wirksamkeit. Sofort bestätigte externe Doppelbuchungen bleiben wirksame **Konfliktfälle**, nicht automatisch ablehnbare Anfragen. Eine vorgeschlagene Livefreigabe/10-Minuten-Karenz ist derzeit nur **optionales Zukunfts-/Integrationskonzept**, kein Ist-Ablauf.
+
+**Nachträgliche Ereignisse (E-019):** Änderungsanfrage, bestätigte Änderung, Stornierungswunsch und wirksame Stornierung unterscheiden. Ursache, Durchführender, vertragliche Folgen, Belegung und Geldflüsse getrennt dokumentieren.
+
+**Zu vertiefen:** [K01 Preis- und Abrechnungsmodell](K01_Preisstruktur_und_Abrechnung.md), [X01 Belegungskonflikt- und Sperrnachweise](X01_Belegungskonflikte_und_Sperrnachweise.md), [O00 offene Portalfragen](O00_Offene_Portalprueffaelle.md).
--- basis/P05/P05_Abschluss_und_Nachbereitung.md
+++ v0.7/P05/P05_Abschluss_und_Nachbereitung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Abschluss und Nachbereitung
status: entwurf
-version: '0.6'
+version: '0.7'
---
# P05 – Abschluss und Nachbereitung
@@ -28,3 +28,8 @@
## Noch offen
Genaue Abschlusskriterien und erforderliche Nachweise; Zuständigkeit und Verknüpfung nachlaufender Folgeprozesse; Objektbereitstellung und Abgrenzung zum Folgeaufenthalt; alternativer Ausgang bei Stornierung oder abgebrochenem Vorgang. **Ob die technische Buchungsakte geschlossen wird oder nur der V01-Prozessstatus wechselt, ist nicht entschieden.**
+
+
+## Ergänzung v0.7: Abrechnung und Nachweislücken
+
+Eine Buchung darf nach erbrachter Leistung fachlich regulär enden, selbst wenn **Provisionsaufschlüsselung, ausstehende Auszahlung oder ungeklärte Sammelgebühren** in einem gesondert zugewiesenen Folgefall weiterbearbeitet werden. Gastbezogene offene Forderungen, Storno- oder Auszahlungsdifferenzen müssen mit Quelle, Verantwortlichem und Buchungsreferenz nachvollziehbar übergeben werden. Fehlende detaillierte Preisaufteilung ist nicht automatisch eine unvollständige Gastleistung.
--- basis/P03/P03_Buchungsverwaltung_und_Abwicklung.md
+++ v0.7/P03/P03_Buchungsverwaltung_und_Abwicklung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungsverwaltung und kaufmännische Abwicklung
status: entwurf
-version: '0.6'
+version: '0.7'
---
# P03 – Buchungsverwaltung und kaufmännische Abwicklung
@@ -26,3 +26,16 @@
## Noch offen
Mindestdaten je Portalprofil, eigene versus externe Zahlungsstände, Reconciliation, Übergänge zum Abschluss.
+
+
+## Flexible Preis- und Zahlungsbearbeitung v0.7
+
+1. Übernommene Positionen **unverändert mit Quelle** speichern: Einzelpositionen, Misch-/Sammelbeträge oder nur verbindlichen Gesamtbetrag. Fehlende Details nicht als 0 interpretieren.
+2. **Preis-/Kostenbeziehungen** unterscheiden: Gast ↔ Vermieter (Mietforderung und enthaltene Leistungen); Gast ↔ Portal (mögliche eigene Servicegebühr); Vermieter ↔ Portal (Provision/Servicekosten); Zahlungen, Rückerstattungen und spätere Auszahlungen jeweils separat.
+3. **Manuelle Ergänzung und Aufteilung** ermöglichen (auch ohne Portal-API): originalen Sammelbetrag erhalten, abgeleitete Teilpositionen zuordnen, Summen abstimmen, doppelte Zählung verhindern. Nicht bekannte Debitoren/Kreditoren, Rabattbezüge und Gebührenarten als **ungeklärt** führen.
+4. **Zahlungsstände** trennen: Gast-Fälligkeit, portalbestätigte Gastzahlung, Auszahlungsvorschau, tatsächlicher Geldeingang, Abweichung/Erstattung. Widersprüche als Klärung auf derselben Buchungsakte, nicht heimlich mit Eigenkalkulation ausgleichen.
+5. **Pflicht nur je Tätigkeit:** Fehlt für eine von uns zu stellende Rechnung die rechtlich nötige Aufschlüsselung, Klärungsaktivität einplanen. Fehlende reine Vermieter-Kostenanalytik darf Anreise oder andere unabhängige Schritte nicht grundsätzlich sperren.
+6. **Destination Solutions A3:** Vermieter führt Vertrag, Zahlungsanforderung, Zahlungskontrolle und ggf. Stornobearbeitung; Höhe der Vermittlerprovision je Herkunft unterschiedlich möglich. Keine zusätzliche Provisionsrechnung an den Gast ohne vorbestehende Vereinbarung.
+7. **FeWo-direkt A4:** Sichtbarer Gastzahlungsplan und erwartete Auszahlung ersetzen weder den Beleg über Bankeingang noch vollständige Gebührenaufschlüsselung; siehe konkrete A4-Screenshots und offenen 5,51-€-Differenzfall.
+
+[Vertiefung: K01](../K01_Preisstruktur_und_Abrechnung.md).
--- basis/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
+++ v0.7/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungseingang und Verfügbarkeitssicherung
status: entwurf
-version: '0.6'
+version: '0.7'
---
# P01 – Buchungseingang und Verfügbarkeitssicherung
@@ -29,3 +29,13 @@
## Noch offen
Mindestfelder nach Eingangstyp, Übergaberegeln für unklare iCal-Ereignisse, Konfliktverhalten, genaue Hold- und Kalenderregeln.
+
+
+## Praxisfälle und Aktivitätsvarianten v0.7
+
+- **FeWo-direkt (A4):** Sofortbuchung kann während verzögertem iCal-Abgleich entstehen. Portal-Verfügbarkeitsstatus darf nicht als Echtzeitgarantie dargestellt werden; eigenes Sync-Ereignis, Zeitpunkt des Abrufs und bekannte Konflikte festhalten.
+- **Destination Solutions (A3):** Im konkret genutzten Zugang **keine aktive Kalender-Synchronisation** laut Betreiber; externe neue Buchung kommt bereits verbindlich an. Andere Vertriebskanäle müssen im Portal **manuell blockiert** werden; nachgelagerter Partnervertrieb kann weitere Verzögerungen verursachen. Eigene protokollierte Aufgabe mit Zeitpunkt, Bearbeiter, Portalanzeige/Screenshot (wenn möglich) – keine Behauptung, der Portalserver habe eine rechtzeitige Übernahme quittiert.
+- **Portalunabhängig:** Art des Belegungs-Inputs (iCal, API, E-Mail, manuell), Ausführungspfad (automatisch/manuell/hybrid), Verzögerung/Unsicherheit und Kontrollmöglichkeiten im Portalprofil hinterlegen. Neue, extern **bereits verbindliche** Kollisionsbuchung als Konflikt behandeln; keine stillschweigende Ablehnung oder Löschung.
+- **Drei Sperrzustände:** `Sperrung veranlasst`, `im Zielportal sichtbar`, `nachweislich im relevanten Vertrieb wirksam`. Fehlender Nachweis bleibt **unbekannt**. Für eigene Holds eigene atomare Freihaltung und Sicherung des bindenden Angebots prüfen, ohne fremde Echtzeitwirkung zu versprechen.
+
+Siehe [X01 – Konfliktmanagement und Nachweise](../X01_Belegungskonflikte_und_Sperrnachweise.md).
--- basis/R00_Szenarien/00_Szenariomatrix.md
+++ v0.7/R00_Szenarien/00_Szenariomatrix.md
@@ -4,7 +4,7 @@
titel: Buchungsszenarien und Vergleichsfälle
autor: FewoPortal Fachinterview
status: diskussionsentwurf
-version: '0.1'
+version: '0.2'
---
# R00 – Buchungsszenarien und Vergleichsfälle
@@ -18,7 +18,12 @@
| R03 | Unverbindliche Portalanfrage | Portal-Anfrage → eigenes Angebot → Annahme | Fehlende Gastdaten, Portal-Kommunikation | Vorgemerkt |
| R04 | Verbindliche Portalbuchung, Vertrag durch uns | Bereits extern verbindlich | Externer bindender Preis, nachträgliche Vertragsdokumentation ohne erneute Annahme, Zahlung je Portal | Vorgemerkt |
| R05 | Portal wickelt verbindliche Buchung vollständig ab | Bereits extern verbindlich | Lokale Leistung und notwendige Informationen, Portal für Vertrag/Zahlung/Mahnung/Storno zuständig | Vorgemerkt |
-| R06 | Hub/Partnerportal | Je Herkunft Anfragen oder Direktbuchungen | Herkunftserkennung bestimmt Profil | Vorgemerkt |
+| R06 | (Historisch) Hub-/Partnervermittlung | Kein eigener Buchungsprozess; A1–A5 richten sich nach Bindung/Abwicklungszuständigkeit | Herkunft allenfalls für Provision/Auswertung relevant | Als separates Szenario nicht weiterführen (E-012) |
| R07 | Eigenbelegung/Sperre | Keine Gastbuchung | Belegungsmanagement ohne Gästeakte | Angrenzender Fall, kein vollständiger V01-Buchungsweg |
**Quellen:** Ausgangsdokumente vom 30./31.10.2026 und Entscheidungsstand der Prozessarchitektur v0.6. Die Bearbeitungsstände beziehen sich auf das Fachinterview, nicht auf die Implementierung.
+
+
+## Ergänzung v0.2: Externe Direktbuchung
+
+**R08 – Destination Solutions (A3):** Bereits verbindliche Buchung, danach Vertrags-/Zahlungs-/Gastabwicklung durch Vermieter; manuelle Sperre externer Kalender, kein belegter Partner-Sync; unterschiedliche Vermittlerprovisionen je Kanal, zusätzliche Gastgebühren und einzelne Preispositionen derzeit unklar. **A6 entfällt** als Archetyp. [R08 Referenzfall](R08_Destination_Solutions.md).
--- basis/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
+++ v0.7/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Leistungsvorbereitung und Aufenthalt
status: entwurf
-version: '0.6'
+version: '0.7'
---
# P04 – Leistungsvorbereitung und Aufenthalt
@@ -25,3 +25,8 @@
## Noch offen
Ob die Organisation des Objektbetriebs vollständig als Supportprozess geführt wird; örtliche Anforderungen; Übergabe- und Eskalationsstandards.
+
+
+## Ergänzung v0.7: externe Kommunikationszuständigkeit
+
+Bei Portal-Direktbuchungen unterscheiden: Portal kündigt Gastnachricht an, Portalversand ist tatsächlich bestätigt oder Vermieter versendet eigene Informationen. FeWo-direkt kündigt in der gezeigten Buchung eine E-Mail etwa 72 Stunden vor Anreise an; dies ist **noch kein Nachweis**, dass sie dem Gast zugegangen ist. Falls erforderliche Gäste-/Meldedaten fehlen, manuell nachfordern. Bei Destination Solutions führt Vermieter die Gast- und Dienstleisterkommunikation im Rahmen der eigenen Abwicklung.
--- basis/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
+++ v0.7/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Konditionen und Buchungsverbindlichkeit
status: entwurf
-version: '0.6'
+version: '0.7'
---
# P02 – Konditionen und Buchungsverbindlichkeit
@@ -49,3 +49,13 @@
- [§ 148 BGB – Bestimmung einer Annahmefrist](https://www.gesetze-im-internet.de/bgb/__148.html)
- [§ 150 BGB – verspätete und abändernde Annahme](https://www.gesetze-im-internet.de/bgb/__150.html)
- [§ 312j BGB – Besonderheiten im elektronischen Geschäftsverkehr](https://www.gesetze-im-internet.de/bgb/__312j.html)
+
+
+## Konditions- und Vertragsprofile v0.7
+
+- **Kanalabhängige Vorlagen:** Für A1/A2 bindendes Angebot einschließlich wirksam zur Kenntnis gegebener Bedingungen; für A3/A4 Dokumentation bereits extern abgeschlossener Buchung; für A5 nur die zur eigenen Tätigkeit nötigen Unterlagen. Vorlagen/Anlagen je Vermieter, Objekt, Portal und Buchungstyp unterscheiden, Version + verwendeten Konditionsstand aufbewahren.
+- **Extern verbindliche Preisgrundlage:** Der bestätigte Gastpreis kann lediglich **als Gesamtbetrag** vorliegen. Dies ist kein Grund, Tagespreise oder einzelne Gebühren zu erfinden. Vom Portal selbst erhobene Gast-Servicegebühren und Vermieterprovisionen können davon abweichen und separat oder nur aggregiert bekannt sein.
+- **Vorvertragliche Einbeziehung:** Ob dem Gast vor Abschluss Stornostaffeln, Pflichtgebühren und sonstige Bedingungen angezeigt wurden, ist je Portal zu prüfen; ein nachträgliches Dokument erzeugt nicht automatisch neue Vertragspflichten.
+- **Destination Solutions:** Genannte Stornostaffel (vom Betreiber berichtet): mindestens 60 Tage vorher 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, 11 Tage oder weniger 100 % des „Mietpreises“. **Ungeklärt:** Nachweis im Buchungsprozess, Durchsetzbarkeit, genaue Kostenbasis. Nicht als globalen A3-Standard verwenden.
+
+Siehe [K00](../00_Portalprofile_und_Vertragsvorlagen.md), [K01](../K01_Preisstruktur_und_Abrechnung.md) und [R08 Destination Solutions](../R00_Szenarien/R08_Destination_Solutions.md).
--- /dev/null
+++ v0.7/D00_Dokumentationsregel_und_Uebergabe.md
@@ -0,0 +1,34 @@
+---
+id: D00
+typ: arbeitsregel
+titel: Dokumentationsregeln, Quellenbasis und Übergabe
+status: diskussionsentwurf
+version: "0.1"
+stand: 2026-10-31
+---
+
+# D00 – Dokumentationspflege und Kontextübergabe
+
+**Verbindliche Arbeitsvereinbarung des Betreibers vom 31.10.2026:**
+
+> **Vor jeder zukünftigen Änderung oder Erweiterung der Fachdokumentation muss ChatGPT den Betreiber ausdrücklich bitten, die aktuell gültigen Originaldokumente erneut bereitzustellen.** Nicht aus Erinnerung oder einem alten Chat-ZIP heraus eine bestehende Datei überschreiben. Maßgebliche Ablage bleibt **Gitea**. Dieser Stand v0.7 ist eine **lokale konsolidierte Bearbeitungsfassung**, kein nachgewiesener Gitea-Stand.
+
+## Vorgehen bei der nächsten Dokumentationsänderung
+
+1. **Vor dem Editieren** aktuelle Gitea-Originaldateien bzw. aktuellen Export/Snapshot **explizit beim Betreiber anfordern** (auch wenn eine ältere Version in /mnt/data oder der Chat-Historie vorhanden ist).
+2. Vergleich mit diesem Stand / bisherigen Entscheidungen, YAML-Metadaten, Dokumenten-IDs und Verlinkungen; Unterschiede und mögliche Konflikte aufzeigen.
+3. Nur auf dem bestätigten Stand weiterarbeiten; bestehende Inhalte nicht still kürzen, vereinbarte Regeln nicht als unbelegte Produktfunktionen ausgeben.
+4. Versionsnummern je geändertem Dokument erhöhen, Entscheidungshistorie und Prüffälle aktualisieren; Änderungen via **Diff/Manifest** nachvollziehbar machen.
+5. Dateipaket zur **kontrollierten Übernahme nach Gitea** bereitstellen; keine Behauptung, Dateien seien bereits im Repository gespeichert. Unklare Rechts-/Portalfragen offen kennzeichnen.
+
+## Quellen und Sicherungsstand der jetzigen Konsolidierung
+
+- Ausgangsbasis Hauptdokumentation: `FewoPortal_Dokumentation_v0.6.zip` **einschließlich P01–P05, die im separaten entpackten Ordner fehlten**.
+- Zusätzliche Ausgangsbasis: `FewoPortal_Portalprofile_Update/{00_Buchungsarchetypen.md v0.5, 00_Portalprofile_und_Vertragsvorlagen.md v0.1, A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md v0.4}`.
+- Weiteres Referenzmaterial: `FewoPortal_R01_Arbeitsentwurf/R00_Szenarien/{00_Szenariomatrix.md, R01_Eigene_Webseite.md}`.
+- Nachzutragende Betreiberangaben: Gespräch vom 31.10.2026 zu FeWo-direkt-Screenshots, Destination Solutions, fünf Archetypen, Storno, unsicheren Kalendern und flexibler Preis-/Gebührenbearbeitung.
+- **Nicht verifiziert:** Ob in Gitea neuere Fassungen dieser Dateien existieren. Vor künftigen Änderungen deshalb erneute Anforderung.
+
+## Kompakter Kontext für den nächsten Chat
+
+FewoPortal ist eine **kleine, mandantenfähige Vermieterwebsite-/Buchungsanwendung für typischerweise 1–3 Ferienwohnungen je Vermieter, kein Marktplatz**. Ein gemeinsamer Hauptprozess V01 P01–P05, dazu V02 Vermarktung/Gästegewinnung/Gästebindung. Fünf Archetypen: A1 eigene Webseite, A2 externe unverbindliche Anfrage, A3 externe verbindliche Buchung mit weiterer eigener Gesamtabwicklung (**Destination Solutions**), A4 externe verbindliche Buchung mit geteilter Abwicklung (**FeWo-direkt**), A5 überwiegend externe Vollabwicklung. **A6 gestrichen**; Partnerherkunft nur bei Provisionsrelevanz. Ein Vorgang/eine Akte. Externer Preis und beim Vertragsschluss vereinbarte Bedingungen bleiben maßgeblich, spätere Dokumente keine stillen neuen Pflichten. Unterschiedliche/versionierte Vorlagen pro Kanal/Buchungstyp. Portale liefern unterschiedlich vollständige Daten; **manuelle Bearbeitung und Sammel-/Gesamtpreise** sind konstitutive Fachfunktionen. Gast-Mietforderung, externe Gastgebühr, Vermieterprovision, Auszahlung und Zahlung getrennt. Kein Erfinden unbekannter Gebührenanteile. Verfügbarkeit extern nicht garantiert: FeWo-direkt verzögerter iCal-Import, Destination Solutions manuelles Sperren ohne verlässlichen Portal-/Partnernachweis; Doppelbuchungen möglich, deshalb Ausnahmeprozess und Belegkette. Nicht bekannte Vertrags- und Portalfragen im O00-Prüffallregister. **Vor der nächsten Dokumentbearbeitung aktuelle Gitea-Fassung explizit erfragen.**
--- /dev/null
+++ v0.7/K01_Preisstruktur_und_Abrechnung.md
@@ -0,0 +1,73 @@
+---
+id: K01
+typ: fachliches-konzept
+titel: Preis-, Gebühren- und Abrechnungsinformationen
+status: diskussionsentwurf
+version: "0.1"
+stand: 2026-10-31
+---
+
+# K01 – Flexible Preis-, Gebühren- und Abrechnungsinformationen
+
+**Fachstatus:** Betreiberentscheidungen E-014/E-015 sind bestätigt; konkrete Feldliste/Technik, Steuern und portalbezogene Berechnungsregeln bleiben zu validieren. Zielgruppe: kleine Vermieter (typischerweise 1–3 Wohnungen), keine komplexe Vollbuchhaltung.
+
+## 1. Zentrales Prinzip
+
+Portale können vollständige Einzelposten, **nur Teilaufschlüsselungen**, **kombinierte Sammelgebühren** oder ausschließlich einen **Gesamtpreis** bereitstellen. FewoPortal muss all diese Informationsstände aufnehmen und später ergänzen können. **Die Gesamtpreisangabe ist ein gültiger Ausgangswert; sie berechtigt nicht zur Erfindung unbekannter Einzelpreise.** Extern bestätigter Gastpreis bleibt Grundlage der bestehenden Buchung.
+
+## 2. Unbedingt zu unterscheidende wirtschaftliche Sachverhalte
+
+| Dimension | Beispiel | Fachliche Bedeutung / Grenze |
+|---|---|---|
+| **Gast ↔ Vermieter** | Vereinbarte Unterkunftsmiete, ggf. vertragliche Zusatzleistungen und Rabatte | Eigene Mietforderung gegenüber Gast; tatsächlich vereinbarter Gastpreis maßgeblich |
+| **Gast ↔ externes Portal** | Eventuelle Vermittlungs-/Servicegebühr des Portals | Fremde Forderung, nicht automatisch unsere Miete oder unser Umsatz |
+| **Vermieter ↔ Vermittler/Portal** | Provision, Transaktionskosten, sonstige vertragliche Dienstleistung | Eigene Kosten des Vermieters; nicht nachträglich dem Gast belasten |
+| **Gastzahlungen** | Anzahlung/Restzahlung, Erstattung, Kaution | Zahlungsplan und Zahlungsstatus unabhängig von der Mietforderung |
+| **Auszahlung an Vermieter** | Nettoauszahlung nach Portalabzügen | Ist-Zahlungsfluss; nicht mit Gastpreis oder vereinbartem Mietbetrag gleichsetzen |
+| **Ungeklärte Mischposition** | Eine „Servicepauschale“ mit unbekanntem Anteil an Reinigung, Portalgebühr oder Provision | **Nicht ohne Nachweis in Einzelpositionen umwandeln**; Zahler/Empfänger ggf. offen |
+| **Preisdifferenz/Vertriebsaufschlag** | Höherer Endpreis auf Partnerkanal möglich | Nur bei Nachweis; unterscheiden von gesonderter Gastgebühr und Vermieterprovision |
+
+**Begriffe:** „Brutto“, „Netto“, „Provision“ und „Servicegebühr“ können auf Portalen unterschiedlich verwendet werden. Keine umsatzsteuerliche Zuordnung ohne überprüfte Angaben. Für die Rechnungsstellung sind tatsächlich geschuldete Leistungen/Steuerregeln separat rechtlich/kaufmännisch zu prüfen.
+
+## 3. Fachliche Positionsstruktur – Vorschlag, noch keine technische Datenmodellfreigabe
+
+Je Position oder Aggregateintrag mindestens soweit bekannt: Bezeichnung, Betrag, Währung, positive/negative Wirkung, **Art der Position** (Einzelpreis, Teilaggregat, Gesamtbetrag, Rabatt, Zahlung, Aufwand, Auszahlung, unbekannt), **wer schuldet wem**, Preis-/Leistungsbezug, Quelle und Erfassungszeitpunkt, zugehörige Buchung und Konditionsstand, Status/Nachweis. Optional: Zeitraum, Menge, Steuerregel, ursprüngliche Portalzeile, externe Referenz, Verknüpfung zu Teilpositionen.
+
+**Qualitäts- und Nachweisstatus:** vom Portal behauptet / im Portal sichtbar / durch Beleg belegt / manuell übernommen / abgeleitet mit Rechenweg / unbekannt / widersprüchlich / nicht anwendbar. Das sind fachliche Kategorien, kein verbindlich vorgeschriebenes Enum.
+
+### Regeln zur Zerlegung und zum Summenabgleich
+
+1. **Original erhalten:** Jede Portal-Sammelposition bleibt mit Ursprung und Betrag historisch erhalten, auch nach Aufteilung.
+2. **Zerlegung mit Rechenweg:** Teilpositionen nur bei ausreichender Quelle oder ausdrücklicher dokumentierter manueller Zuordnung. Rest bleibt als „ungeklärter Anteil“.
+3. **Doppelzählung vermeiden:** Ein Gesamtaggregat und seine Unterpositionen dürfen in Summen **nicht additiv** gezählt werden. Die Aggregationshierarchie bleibt nachvollziehbar.
+4. **Keine Scheingenauigkeit:** Nur Gesamtpreis bekannt → keine Tagespreise aus Durchschnittswert als tatsächliche Portalpreise deklarieren. Interne Vergleichskalkulation ausdrücklich von Vertragsfakten trennen.
+5. **Widersprüche erhalten:** Zwei verschiedene Portal-Auszahlungswerte bleiben beide mit Herkunft stehen, bis sie belegt geklärt werden.
+6. **Keine Umdeutung der Vertragspflicht:** Aufteilung, interne Provision oder Auszahlung ändern den verbindlichen Gastpreis nicht rückwirkend.
+7. **Korrekturen historisieren:** Neue Information ergänzt oder korrigiert die interne Zuordnung nachvollziehbar; die ursprünglichen Portalwerte bleiben referenzierbar.
+
+## 4. Beschaffung und manuelle Bearbeitung
+
+- **Automatisch:** Datenimport per vorhandener Schnittstelle, Parser oder anderem verlässlichen Kanal, soweit die Daten tatsächlich verfügbar sind.
+- **Manuell:** Vermieter ruft Portalbestätigung, Posteingang oder Abrechnungsseite auf, erfasst Werte und kann Belege/Screenshot hinterlegen.
+- **Hybrid:** Automatisch importierter Gesamtpreis, manuell nacherfasste Provision oder einzelne Gebühren.
+- **Klärungsaufgabe:** Wenn tatsächlich für die **nächste Fachhandlung** erforderlich, z. B. noch fehlender Betrag zur korrekten Gastrechnung oder Zahlungseinforderung.
+- **Kein unnötiger Prozessstopp:** Rein interne Provisionszerlegung oder fehlende Tagespreise blockieren nicht automatisch bereits verbindliche Buchung, Kalender- oder Anreisevorbereitung.
+
+## 5. Getrennte Finanzzustände (kein unzulässiger Statusschluss)
+
+`Gastbetrag vereinbart` → `Rate fällig` → `Rate laut Portal bezahlt` → `Auszahlung angekündigt` → `Auszahlung auf Bankkonto belegt`. Diese Ereignisse sind **nicht zwangsläufig linear** und nicht in allen Portalen sichtbar. Eine sichtbare „bezahlt“-Markierung ist noch kein eigener Zahlungseingang beim Vermieter; Kaution, Mietzahlung, Gebühr und Erstattung gesondert betrachten.
+
+## 6. Reale Prüfbeispiele
+
+**FeWo-direkt A4 – beobachteter Screenshot, Buchung 10.–17.07.2027:** 840,00 € Übernachtungen, −42,00 € Rabatt, +181,51 € „Gebühren und Steuern“, 979,51 € Gastgesamtbetrag, −84,82 € „An FeWo-direkt gezahlt“, 894,69 € ausgewiesene Gesamtauszahlung. In anderer Ansicht 900,20 € erwartete Auszahlung (5,51 € Differenz). Sichtbarer Zahlungsplan 390,61 € bezahlt und 588,90 € später fällig. **Keine belegte Zerlegung** von 181,51 €/84,82 € oder der 5,51-€-Differenz; einzelne Tagespreise fehlen. Siehe [A04 Abschnitt 7](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md).
+
+**Destination Solutions A3 – Betreiberangaben:** Extern bestätigter Buchungspreis ist zu übernehmen und Zahlung durch Vermieter abzuwickeln. Provisionssatz kann nach vermittelndem Partner variieren. Ob Partnerportal den Endpreis erhöht oder eine separate Gast-Servicegebühr erhebt, ist derzeit nicht bestätigt; auch dort darf nur ein übermittelter Gesamtpreis zulässig sein. Keine nachträgliche Provisionsbelastung des Gastes.
+
+## 7. Noch zu entscheiden
+
+- Für welche Dokumente/Rechnungen ist eine echte Einzelpositionsauflösung zwingend? Gesetzliche Buchführungs-/Umsatzsteuerpflichten jeweils gesondert prüfen.
+- Wie sollen Rundungsdifferenzen, Fremdwährungen, Kaution, Kurabgabe, Auszahlungstermine und Teilrückerstattungen technisch dargestellt werden?
+- Welche Vereinbarungen gelten für Stornokostenbasis („Mietpreis“ vs. Gesamtbetrag; inkludierte/ausgeschlossene Leistungen), wenn nur eine Gesamtsumme vorliegt?
+- Welche individuellen Portalberichte, tatsächlichen Zahlungsnachweise und Importformate stehen zur Verfügung?
+
+**Fachliche Herkunft:** Betreiberinterview vom 31.10.2026, FeWo-direkt-Screenshots, [E00 E-014–E-020](E00_Entscheidungsprotokoll.md). Rechtliche Gestaltung separat prüfen.
--- /dev/null
+++ v0.7/O00_Offene_Portalprueffaelle.md
@@ -0,0 +1,49 @@
+---
+id: O00
+typ: prueffallregister
+titel: Portalbezogene Prüf- und Klärungsfälle
+status: diskussionsentwurf
+version: "0.1"
+stand: 2026-10-31
+---
+
+# O00 – Offene Portalprüffälle / spätere Konfiguration
+
+**Status:** Keine offenen Fragen als beantwortet ausgeben, solange konkrete Portalansichten, Verträge, Anbieterantworten oder Gastbuchungen fehlen. Unterschiedliche Vermieter-/Portalverträge können unterschiedlich sein. Die untenstehenden Prüfpunkte sind **keine Vorbedingungen für alle Prozessschritte**.
+
+## A. Destination Solutions / Kühlungsborn (A3)
+
+| ID | Prüffall | Bekannter Stand | Erforderlicher Nachweis / spätere Konfiguration |
+|---|---|---|---|
+| DS-01 | Erhält Gast Stornobedingungen **vor** verbindlicher Buchung? | Staffel laut Betreiber separat im späteren Vertrag; Betreiber vermutet ggf. Portal-Einstellungen / Hinweis | Gast-Buchungsstrecke, Gast-Bestätigung, Portal-AGB/Smart-Account-Einstellungen, ggf. Betreibervereinbarung |
+| DS-02 | Welche Basis ist „Mietpreis“ für Storno? | Unklar, ob Übernachtung allein oder zusätzliche Leistungen | Vertrag/Preisaufschlüsselung und rechtliche Prüfung |
+| DS-03 | Gibt es eigene Gast-Servicegebühr oder Partner-Aufschläge? | **Unbekannt**; nur unterschiedliche **Vermieterprovisionen** je Vermittlungskanal sind berichtet | Gastansicht/Gastbestätigung plus Provisionsrechnung des konkreten Kanals |
+| DS-04 | Vollständiger Preisnachweis | Buchung kommt mit Gesamtinformationen; Einzelposten nicht gesichert | Beispieldokumente/Muster einer echten Buchung; Fähigkeit „nur Gesamtpreis“ zulassen |
+| DS-05 | Kalender-/Sperrprotokoll | Nach Betreibererfahrung **manuelle Sperre, kein formaler Sperrnachweis** | Anbieterantwort zum Serverzeitstempel, Änderungslog und Partnerweitergabe |
+| DS-06 | Verfahren und Zuständigkeit für Storno/Umbuchung | Noch kein durchlaufener Prozess beschrieben | Portalvertrag, Beispielbuchung, konkrete Änderung/Storno aus Praxistest wenn möglich |
+
+## B. FeWo-direkt (A4)
+
+| ID | Prüffall | Bekannter Stand | Benötigter Nachweis |
+|---|---|---|---|
+| FW-01 | Welche Dokumente/Bedingungen werden vor verbindlicher Buchung gezeigt? | Eigene vierseitige Vertragsvorlage **nicht** im Portal hochgeladen; exakte Gastansicht unbekannt | Gastansicht, Buchungsbestätigung, Portal-AGB und tatsächlich bei Buchung vereinbarte Konditionen |
+| FW-02 | Sind Gast-Servicegebühr, Portalabzug, Vermieterprovision und Steuerbestandteile trennbar? | Im Screenshot Gesamt- und Teilaggregationen; 181,51 € „Gebühren und Steuern“, 84,82 € „An FeWo-direkt gezahlt“ nicht weiter zerlegt | Vollständige Detailansicht/Provisionsabrechnung, ggf. vertraglicher Abgleich |
+| FW-03 | Wieso zwei Auszahlungsbeträge? | 894,69 € und 900,20 € (Differenz 5,51 €) | Ursachenprüfung anhand derselben Buchung und Zahlungskonto |
+| FW-04 | Welche Zahlungsdaten sind wirklich exportierbar? | Posteingang pro Buchung mit Raten, jedoch allgemeiner Zahlungsverlauf/Export vom Betreiber als unzureichend beschrieben | Exporttest, Auszahlungsbeleg und tatsächlicher Bankeingang |
+| FW-05 | Änderungs- und Stornoprozess / Sanktionen | Betreiber hat bisher selbst weder Vermieterstorno noch Änderung ausgeführt | Portalregeln, Betreiberkonto, konkrete Verfahrensnachweise; tatsächliche Ursache korrekt klassifizieren |
+| FW-06 | Gastdaten und örtliche Meldepflichten | Vollständige Gastanschrift nicht immer verfügbar | Tatsächlich vom Portal lieferbare Felder und konkret erforderliche lokale Pflichtdaten prüfen |
+| FW-07 | iCal-Übernahme und Nachweis | Verzögerter Fremdkalenderabgleich, reale Doppelbuchungsgefahr | Zeit- und Änderungsnachweise soweit technisch verfügbar; keine Echtzeitgarantie |
+
+## C. Portalübergreifende Rechts-/Funktionsfragen
+
+- **Rechtswirksame Einbeziehung** von AGB, Storno- und Pflichtkosten vor Vertragsschluss bei externen Direktbuchungen; **späterer Dokumentversand ≠ neue automatische Einbeziehung**. Einzelprüfung anhand konkreter Verträge und Buchungsscreens.
+- **Stornokosten**: Wirksamkeit der Pauschalierung und mögliche Abzüge ersparter Aufwendungen / alternative Vermietung; gesetzliche Regeln und Portal-AGB beachten, kein automatisches Rechtsurteil in FewoPortal.
+- **Vollständigkeit**: Unbekannte Posten und aggregierte Beträge sind im Fachmodell ausdrücklich zulässig; der nächste notwendige Schritt kann dennoch manuelle Klärung verlangen.
+- **Verfügbarkeit**: Manuelle Sperre, Zielportal-Sichtbarkeit und partnernetzweite Wirksamkeit unterscheiden. Nicht nachgewiesene Serverbestätigung nicht fingieren.
+- **Datensparsamkeit**: Nur tatsächlich erforderliche Gast- und Mitreisendendaten für Vertrag und anwendbare örtliche Vorschriften erheben.
+
+## D. Was sich vor späterer Konfiguration beschaffen lässt
+
+Pro Portal idealerweise **ein vollständig anonymisierter realer Buchungsfall**, Gast-Buchungsbestätigung soweit vorhanden, Betreiber-Provisionsabrechnung, Preis-/Stornokonfiguration und ein Beispiel für Änderung/Stornierung. **Nicht alle Nachweise müssen jetzt vorliegen**; Fehlen führt zu manuellen Aufgaben oder offenen Informationsfeldern, nicht zum Erfinden von Regeln.
+
+**Referenzen:** [Portalprofil K00](00_Portalprofile_und_Vertragsvorlagen.md), [Preisstruktur K01](K01_Preisstruktur_und_Abrechnung.md), [FeWo-direkt A04](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md), [Destination Solutions R02](R00_Szenarien/R08_Destination_Solutions.md).
--- /dev/null
+++ v0.7/R00_Szenarien/R08_Destination_Solutions.md
@@ -0,0 +1,61 @@
+---
+id: R08
+typ: geschaeftsszenario
+titel: Verbindliche Direktbuchung – Destination Solutions
+status: diskussionsentwurf
+version: "0.1"
+stand: 2026-10-31
+---
+
+# R08 – Destination Solutions: Verbindliche Direktbuchung mit Abwicklung durch Vermieter
+
+**Zuordnung:** A3; Partnerherkunft **kein A6**. Dies ist ein reales, vom Betreiber beschriebenes Referenzszenario, keine Implementierungsfreigabe. Anbieter: [Destination Solutions](https://www.ds-destinationsolutions.com/). Die Angaben beschreiben den **konkret verwendeten Betreiberzugang**, nicht zwangsläufig alle Kunden und Softwareprodukte des Unternehmens.
+
+## 1. Dokumentierter Ist-Sachverhalt (Betreiberangaben)
+
+- Der Anbieter bzw. sein Partnernetz vermittelt und bestätigt Buchungen **verbindlich**, bevor der Vermieter sie erhält.
+- Die Buchung wird dem Vermieter mit den für die weitere Abwicklung vorgesehenen Daten übermittelt; die Abwicklung von **Vertragsunterlagen, Gastkommunikation, Zahlungsforderung/-kontrolle, Aufenthalt und Folgevorgängen** liegt danach beim Vermieter. Einzelne Preis-/Gebührenpositionen können trotzdem fehlen; vollständige kaufmännische Aufschlüsselung ist nicht bestätigt.
+- Für diesen Betreiberzugang gibt es **keinen automatischen Abgleich mit den Vermieterkalendern**. Andere Portale müssen nach Eingang einer Buchung **unverzüglich manuell gesperrt** werden. Für den Zeitpunkt der Portalübernahme/Weitergabe der Sperrung gibt es nach Betreiberangabe **keinen belastbaren Bestätigungsbeleg**.
+- Destination Solutions nutzt zusätzlich Partnervertrieb. Der Vermieter erhält je nach Vertriebspartner **unterschiedliche Provisionen**. Eine unbekannte Gastgebühr oder ein Endpreisaufschlag ist **nicht nachgewiesen** und darf nicht als Tatsache modelliert werden.
+- Beim Buchungsabschluss ist der Preis bereits vereinbart. Unsere Provision an den Vermittler darf daher **nicht nachträglich als Zusatzforderung gegenüber dem Gast** erhoben werden.
+
+## 2. Generischer Sollablauf P01–P05 mit manuellen Aufgaben
+
+| Phase | Tätigkeiten / Abweichung | Gate / Nachweis |
+|---|---|---|
+| **P01 Eingang & Belegung** | Eingehende **bereits verbindliche** Buchung übernehmen, Objekt/Zeitraum/Referenz und Gastdaten zuordnen. Eigene Kalender sofort aktualisieren, für nicht angebundene Portale **manuelle Sperraufgabe** erzeugen, mit Bearbeiter und Zeitpunkt quittieren. Bei Kollision X07. | Buchung verbindlich extern; Sperraufgabe erledigt ≠ nachweislich partnernetzweit wirksam |
+| **P02 Konditionen/Vertrag** | Ursprünglich vereinbarten Gastpreis und bekannte Konditionen übernehmen, nicht selbst nachkalkulieren. Zugehöriges Vertragsprofil/Anlagen auswählen; Gast bereits gebunden – **keine zweite Annahme**. Storno-/Pflichtbedingungen auf vorvertragliche Einbeziehung prüfen. | Quelle für Gastpreis, vertragsrelevante Bedingungen und ggf. offene Rechts-/Datenlücke |
+| **P03 Kaufmännisch** | Eigene Buchungsdokumentation versenden; Zahlungsplan/Anzahlung/Restzahlung festlegen bzw. gemäß Vereinbarung übernehmen, Zahlungen überwachen, Mahn-/Stornofälle selbst führen. Vermittlerrechnung/Provision ggf. nach Kanal zuordnen, Gastservicegebühren nur soweit nachgewiesen. | Eigener Zahlungsstand und offene Finanz-/Konditionsprüfungen erkennbar |
+| **P04 Aufenthalt** | Gastkontakt, lokale Ansprechpartner, Anreise, Schlüssel, Reinigung, Kurabgabe/Meldedaten soweit nötig, Aufenthalt/Abreise. | Erforderliche Leistungsinformationen vorhanden; manuelle Schritte möglich |
+| **P05 Abschluss** | Aufenthalt abschließen, Feedback, finanzielle Rest-/Provisionsprüfung ggf. Folgefall. | V01 regulär beendet oder offener Nachläufer verantwortlich übergeben |
+
+## 3. Betreiberangabe zu Stornobedingungen
+
+| Zeit vor Mietbeginn | Stornopauschale vom „Mietpreis“ |
+|---|---:|
+| 60 Tage oder mehr | 0 % |
+| 59–45 Tage | 35 % |
+| 44–33 Tage | 50 % |
+| 32–22 Tage | 70 % |
+| 21–12 Tage | 90 % |
+| 11 Tage oder weniger | 100 % |
+
+**Wichtige Einschränkung:** Der Betreiber ist nicht sicher, ob diese Bedingungen **bereits vor der Buchung** im Portal angezeigt und wirksam einbezogen wurden oder erst mit dem eigenen, nachträglich übersandten Vertrag vereinbart werden sollen. Ein späteres Dokument kann nicht ohne Weiteres einseitig neue Pflichten begründen. Auch ob „Mietpreis“ nur Übernachtungen oder Zusatzleistungen enthält und wie 90–100 % als Pauschalierung rechtlich einzuordnen sind, muss geprüft werden. Siehe [§ 305 BGB](https://www.gesetze-im-internet.de/bgb/__305.html), [§ 309 Nr. 5 BGB](https://www.gesetze-im-internet.de/bgb/__309.html) und [§ 537 BGB](https://www.gesetze-im-internet.de/bgb/__537.html) als Prüfquellen, **nicht als abschließendes Rechtsgutachten**.
+
+## 4. Finanzielle Unklarheiten / Konfigurationsfragen
+
+1. Wird die vereinbarte Gastmiete vom Portal oder einem Partnerportal **durch eigene Gast-Servicegebühr** ergänzt?
+2. Werden je Vermittlungskanal unterschiedliche **Gäste-Endpreise/Vertriebsaufschläge** berechnet?
+3. Wie werden Provisionskosten und die (eventuell andere) **vertragliche Mietforderung** beim Vermieter nachgewiesen?
+4. Welche Beträge/Positionen sieht der Gast vor dem Abschluss und in der Gast-Buchungsbestätigung?
+5. Wie ist die **Stornokostenbasis** bei unbekannten Einzelpreisen definiert; was passiert bei optionalen Leistungen und Neuvermietung?
+
+## 5. Risiko: Nachweislose Sperrung trotz Sofortbuchung
+
+Das System muss die **eigene Ausführung** dokumentieren (Sperraufgabe, Zeitstempel, Screenshot sofern verfügbar) und gleichzeitig ehrlich kennzeichnen, dass kein Nachweis über den Servereingang bzw. die Partnernetz-Verteilung vorliegt. Buchungsüberschneidungen können auch dann auftreten, wenn der Vermieter schnell handelt. **Technisch verursachte Verzögerung beweist für sich genommen keine rechtliche Entlastung.** Livefreigabe durch Vermieter oder Karenzfrist sind hier **nicht vorhandene Ist-Funktionen** und bleiben lediglich hypothetische Integrationsoptionen.
+
+## 6. Quellen- und Verifizierungsstatus
+
+- **Bestätigt aus dem Betreiberinterview:** verbindliche Buchungsübermittlung, komplette weitere Vermieterabwicklung, manuelle Sperre ohne Bestätigungsbeleg, unterschiedliche Vermittlerprovisionen je Partner, Stornostaffel als genannte Vertragsbedingung.
+- **Nicht verifiziert:** konkrete Ansicht/Bestätigung des Gastes, Vertragseinbeziehung der Stornoregeln, zusätzliche Gastgebühren oder Aufschläge, Preisaufschlüsselung, verwendete Destination-Solutions-Vertragsvariante, technische Verteilung/Protokollierung.
+- Weitere Nachweise erforderlich: [O00](../O00_Offene_Portalprueffaelle.md).
--- /dev/null
+++ v0.7/X01_Belegungskonflikte_und_Sperrnachweise.md
@@ -0,0 +1,41 @@
+---
+id: X07-DOK
+typ: sonderprozess
+titel: Verfügbarkeitsabgleich, Sperrnachweise und Doppelbuchungen
+status: diskussionsentwurf
+version: "0.1"
+stand: 2026-10-31
+---
+
+# X07 – Verfügbarkeitsabgleich, Sperrnachweise und Doppelbuchungen
+
+**Geltungsbereich:** Alle Buchungsarchetypen und Vertriebskanäle. Das Dokument ist eine Vertiefung von X07 aus [X00](X00_Sonderprozesse.md), kein zusätzlicher Buchungsarchetyp.
+
+## 1. Reale Ursachen und Grenzen
+
+- **FeWo-direkt:** Verzögertes iCal-Importintervall kann dazu führen, dass nach einer eigenen verbindlichen Buchung dort noch buchbare Zeiten angezeigt werden. Dass ein eigener Export korrekt aktualisiert wurde, beweist keine rechtzeitige Portalübernahme.
+- **Destination Solutions:** Beim konkreten Vermieteraccount fehlt ein automatischer Kalenderabgleich; manuelle Sperrung im Zielportal. Anschließende Weitergabe an Partnerportale und wirksamer Zeitpunkt sind **nicht verifizierbar**; eine protokollierte Sichtkontrolle des Vermieters ist kein Portalserver-Zeitstempel.
+- **Generische Grenze:** Bei heute sofort wirksam werdenden externen Direktbuchungen verhindert FewoPortal **nicht jede Doppelbuchung**. Vom Betreiber vorgeschlagene 10-Minuten-Bestätigung oder Livefreigabe sind sinnvolle technische Zukunftsoptionen, werden **nicht als bestehende Funktionen** vorausgesetzt.
+
+## 2. Minimale Nachweiskette, ohne Überbürokratisierung
+
+1. **Auslösende Buchung:** Portal/Quelle, externe Referenz, Ankunft der Nachricht, soweit ermittelbarer tatsächlicher Buchungs-/Bestätigungszeitpunkt.
+2. **Eigene Belegungsänderung:** Zeitstempel, interne Buchungs-ID, Zeitraum, Nutzer/Systemaktion, Stand eigener Kalender.
+3. **Propagation:** Ausgeführter Export oder angelegte manuelle Sperraufgabe; Zeitpunkt und verantwortliche Person.
+4. **Zielportal:** Soweit möglich manuelle Sichtkontrolle und optionaler Screenshot. Status nur **„angezeigt“**, wenn dadurch belegt.
+5. **Partnernetz:** Nur als **„wirksam nachgewiesen“** markieren, falls geeignete Rückmeldung/Protokoll vorhanden; sonst **„unbekannt“**.
+6. **Fehler:** Doppelbuchung → Meldungszeitpunkte, beide Verbindlichkeitsnachweise, mögliche Ursache, Kommunikation und Entscheidung gesondert festhalten.
+
+**Rechtliche Vorsicht:** Ein technisch nicht vermeidbarer Sync-Verzug belegt nicht automatisch fehlendes Verschulden nach Miet- und Portalvertrag. Verantwortlichkeit erst nach Vertrags- und Sachverhaltsprüfung beurteilen. FeWo-direkt-Richtlinien zu Gastgeberstornierungen gesondert beachten; die tatsächliche Ursache nicht durch Gast-Button umdeklarieren.
+
+## 3. Generischer Konflikt-Teilprozess
+
+Konflikt entdecken → unverändert dokumentieren → **bereits verbindliche Buchungen** und Zeitachse prüfen → Ursache/Zuständigkeiten ermitteln → realistische Lösung mit Gästen/Portalen abstimmen → **rechtlich tatsächlich wirksame** Umbuchung/Stornierung oder Alternativleistung dokumentieren → Kalender/Finanzen/Vertragsdokumente aktualisieren → Folgefälle übergeben.
+
+Keine bereits verbindliche externe Buchung nur aufgrund widersprüchlicher Kalenderdaten löschen; keine bloße Stornoanfrage als wirksam verbuchen. Mit dem Gast wird transparent kommuniziert, ohne durch Druck eine abweichende Ursache zu konstruieren.
+
+## 4. Zielarchitektur, nicht Ist-Funktionen
+
+Mögliche spätere technische Fähigkeiten: Live-API-Verfügbarkeitsabfrage, atomare Reservierung, Portalbestätigung vor Vertragsschluss, Webhooks/Audit-Logs, automatische Konfliktfrüherkennung. **Aktuell nicht als verfügbar oder implementiert voraussetzen.** Für den MVP zunächst: gut sichtbare Sperraufgaben und revisionsfähige Eigenprotokolle.
+
+Siehe [P01](P01/P01_Buchungseingang_und_Verfuegbarkeit.md), [E00](E00_Entscheidungsprotokoll.md), [Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md).
@@ -1,689 +0,0 @@
--- v0.7/00_Buchungsarchetypen.md
+++ v0.8/00_Buchungsarchetypen.md
@@ -3,7 +3,7 @@
typ: archetypenkatalog
titel: FewoPortal – Buchungsarchetypen und Verantwortungsübergaben
status: diskussionsentwurf
-version: "0.6"
+version: "0.7"
stand: 2026-10-31
prozess: V01
bezugsstand_prozessarchitektur: "0.7"
@@ -106,32 +106,32 @@
**Zu konfigurierende Kanalmerkmale:** Herkunft verbindlicher Preise/Rabatte/Stornobedingungen, Erkennbarkeit und Nachweise, Zuständigkeiten, erlaubte Dokumente, automatische oder manuelle Datenerfassung und Vertragsversand. Kein hardcodiertes FeWo-direkt-Verhalten.
-Siehe [00 – Portalprofile und Vertragsvorlagen](00_Portalprofile_und_Vertragsvorlagen.md) für das schlanke Referenzmodell.
+Siehe [[00_Portalprofile_und_Vertragsvorlagen|00 – Portalprofile und Vertragsvorlagen]] für das schlanke Referenzmodell.
## 8. Bezug zu vorhandenen Dokumenten
-- [Prozesslandkarte](00_Prozesslandkarte.md) – V01/V02, fünf Phasen und übergreifende Leitregeln.
-- [Gates und Übergaben](G00_Gates_und_Uebergaben.md) – konzeptionelle Gate-Logik.
-- [Entscheidungsprotokoll](E00_Entscheidungsprotokoll.md) – bereits bestätigte Entscheidungen.
-- [Sonderprozesse](X00_Sonderprozesse.md) – derzeit bekannte Ausnahmefamilien.
-- [Referenzfall eigene Webseite](R00_Szenarien/R01_Eigene_Webseite.md) – gesonderter Arbeitsentwurf (sofern dieser bereits ins Repository übernommen wurde).
+- [[00_Prozesslandkarte|Prozesslandkarte]] – V01/V02, fünf Phasen und übergreifende Leitregeln.
+- [[G00_Gates_und_Uebergaben|Gates und Übergaben]] – konzeptionelle Gate-Logik.
+- [[E00_Entscheidungsprotokoll|Entscheidungsprotokoll]] – bereits bestätigte Entscheidungen.
+- [[X00_Sonderprozesse|Sonderprozesse]] – derzeit bekannte Ausnahmefamilien.
+- [[R00_Szenarien/R01_Eigene_Webseite|Referenzfall eigene Webseite]] – gesonderter Arbeitsentwurf (sofern dieser bereits ins Repository übernommen wurde).
## 9. Ergänzende A4-Vertragsanalyse (Stand 31.10.2026)
-Die vom Betreiber bereitgestellte vierseitige FeWo-direkt-Vertragsvorlage wurde unter [A04 – Vertragsvorlage und Prozessanalyse](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md) gesondert bewertet. Besonders prüfbedürftig sind: Verbindlichkeit vor dem nachträglichen Vertragsversand (§ 5), zuvor einbezogene Konditionen, Preis-/Gebührentrennung (§ 4), Portalstorno gegenüber eigener Stornoklausel (§ 13), Datenbedarf sowie sichere Trennung von Vertragsdokument und Zugangs-/Anreiseinformationen. **Keine Änderung der Betreibervertragsklauseln ohne gesonderte rechtliche und fachliche Freigabe.**
+Die vom Betreiber bereitgestellte vierseitige FeWo-direkt-Vertragsvorlage wurde unter [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 – Vertragsvorlage und Prozessanalyse]] gesondert bewertet. Besonders prüfbedürftig sind: Verbindlichkeit vor dem nachträglichen Vertragsversand (§ 5), zuvor einbezogene Konditionen, Preis-/Gebührentrennung (§ 4), Portalstorno gegenüber eigener Stornoklausel (§ 13), Datenbedarf sowie sichere Trennung von Vertragsdokument und Zugangs-/Anreiseinformationen. **Keine Änderung der Betreibervertragsklauseln ohne gesonderte rechtliche und fachliche Freigabe.**
**Status dieses Dokuments:** Fünf Archetypen (A1–A5) nach E-012; Portalprofile und rechtliche Detailfragen bleiben offen. Neben FeWo-direkt (A4) ist Destination Solutions (A3) dokumentierter Praxisfall.
## 10. A4-Praxisnachweis aus FeWo-direkt-Ansichten (31.10.2026)
-Für eine konkrete zukünftige Buchung sind **aggregierte Übernachtungsrate, Rabatt, Gebühren/Steuern, Gesamtzahlung des Gastes, Abzug an FeWo-direkt, Auszahlungsvorschau sowie zwei Zahlungsraten und deren Fälligkeits-/Zahlungsstatus** im Vermieterbereich sichtbar. Auch angezeigte Stornobedingungen und der vorgesehene 72-Stunden-Anreiseinformationsversand sind erkennbar. **Nicht nachgewiesen** sind die vollständigen Tagespreis- und Gebührenbestandteile, ein belastbarer allgemeiner Zahlungsexport, die tatsächliche Auszahlung, der vollständige Vertragsinhalt der Gastbestätigung und die vollständigen Gaststammdaten. Zwei Ansichten weisen zudem **unterschiedliche voraussichtliche Vermieterauszahlungen (900,20 € / 894,69 €)** aus, Ursache offen. Details im [A4-Vertrags- und Prozessdokument](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md#7-nachtrag-aus-belegten-bildschirmansichten-31102026--ist-zustand-nicht-allgemeines-portalverhalten).
+Für eine konkrete zukünftige Buchung sind **aggregierte Übernachtungsrate, Rabatt, Gebühren/Steuern, Gesamtzahlung des Gastes, Abzug an FeWo-direkt, Auszahlungsvorschau sowie zwei Zahlungsraten und deren Fälligkeits-/Zahlungsstatus** im Vermieterbereich sichtbar. Auch angezeigte Stornobedingungen und der vorgesehene 72-Stunden-Anreiseinformationsversand sind erkennbar. **Nicht nachgewiesen** sind die vollständigen Tagespreis- und Gebührenbestandteile, ein belastbarer allgemeiner Zahlungsexport, die tatsächliche Auszahlung, der vollständige Vertragsinhalt der Gastbestätigung und die vollständigen Gaststammdaten. Zwei Ansichten weisen zudem **unterschiedliche voraussichtliche Vermieterauszahlungen (900,20 € / 894,69 €)** aus, Ursache offen. Details im [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse#7. Nachtrag aus belegten Bildschirmansichten (31.10.2026) – Ist-Zustand, nicht allgemeines Portalverhalten|A4-Vertrags- und Prozessdokument]].
**Portalinvariante:** Verantwortlichkeit für Zahlung oder Kommunikation, Portalstatus und tatsächlicher Erfüllungsnachweis sind getrennt zu verwalten.
## 11. Änderungs- und Stornoereignisse (portalunabhängig)
-Ein Storno bzw. eine Buchungsänderung ist ein **Teilprozess auf derselben Buchungsakte**, kein zusätzlicher Archetyp. Die fachliche Ursache (Gastwunsch, Unmöglichkeit beim Vermieter, Doppelbuchung, Regelverstoß, technischer Fehler), der Initiator, der ausführende Beteiligte und die Abwicklungsverantwortung sind voneinander zu unterscheiden. Anfrage, Bestätigung und tatsächliche Wirksamkeit sind getrennte Ereigniszustände. Kalender, Konditionen, Vertrag und Zahlungen werden erst nach ausreichend belegter Wirksamkeit angepasst. Eine durch den Vermieter verursachte Stornierung darf nicht durch Aufforderung an den Gast als Gaststorno umetikettiert werden. **FeWo-direkt** ist dafür ein dokumentiertes Portalbeispiel (siehe [A04 Abschnitt 8](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md)); andere Portale können abweichende Wege, Daten und Zuständigkeiten haben.
+Ein Storno bzw. eine Buchungsänderung ist ein **Teilprozess auf derselben Buchungsakte**, kein zusätzlicher Archetyp. Die fachliche Ursache (Gastwunsch, Unmöglichkeit beim Vermieter, Doppelbuchung, Regelverstoß, technischer Fehler), der Initiator, der ausführende Beteiligte und die Abwicklungsverantwortung sind voneinander zu unterscheiden. Anfrage, Bestätigung und tatsächliche Wirksamkeit sind getrennte Ereigniszustände. Kalender, Konditionen, Vertrag und Zahlungen werden erst nach ausreichend belegter Wirksamkeit angepasst. Eine durch den Vermieter verursachte Stornierung darf nicht durch Aufforderung an den Gast als Gaststorno umetikettiert werden. **FeWo-direkt** ist dafür ein dokumentiertes Portalbeispiel (siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 Abschnitt 8]]); andere Portale können abweichende Wege, Daten und Zuständigkeiten haben.
## 12. Destination Solutions als Praxisreferenz A3 (E-012/E-016/E-017/E-018)
@@ -141,8 +141,12 @@
- **Vermittlerprovisionen** können nach Vertriebskanal variieren. Sie sind nicht nachträglich vom Gast zu fordern. Ob zusätzlich ein direkter Gast-Aufschlag/Serviceentgelt oder Partner-Endpreisaufschlag existiert, muss beim Anbieter und anhand einer Gastbestätigung geprüft werden.
- **Stornostaffel** vom Betreiber angegeben: ≥60 Tage 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, ≤11 Tage 100 % vom „Mietpreis“; **vorvertragliche Einbeziehung, Berechnungsbasis und rechtliche Wirksamkeit offen**.
-Siehe [R08 Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md) und [O00 Offene Portalprüffälle](O00_Offene_Portalprueffaelle.md).
+Siehe [[R00_Szenarien/R08_Destination_Solutions|R08 Destination Solutions]] und [[O00_Offene_Portalprueffaelle|O00 Offene Portalprüffälle]].
## 13. Portaldaten können unterschiedlich detailliert und zusammengesetzt sein (E-014/E-015)
-Bei A2–A5 sind **automatische, manuelle und hybride** Informationen und Tätigkeiten gleichwertig zu modellieren. Pro Buchung sind vollständig aufgeschlüsselte Positionen, **kombinierte Service-/Gebührenpositionen**, bloße Gesamtbeträge sowie nur teilweise verfügbare Zahlungsauszüge möglich. Keine fiktive Zerlegung des Gesamtpreises; unbekannte Gebührenarten, Zahlende/Empfänger und Provisionsanteile bleiben offen. Nachträgliche Zuordnung oder Aufteilung erhält den originalen Portalbetrag und verhindert doppelte Summierung. Fehlende rein interne Kostenanalyse blockiert nicht ohne Weiteres den vertraglichen Aufenthalt. Siehe [K01](K01_Preisstruktur_und_Abrechnung.md).
+Bei A2–A5 sind **automatische, manuelle und hybride** Informationen und Tätigkeiten gleichwertig zu modellieren. Pro Buchung sind vollständig aufgeschlüsselte Positionen, **kombinierte Service-/Gebührenpositionen**, bloße Gesamtbeträge sowie nur teilweise verfügbare Zahlungsauszüge möglich. Keine fiktive Zerlegung des Gesamtpreises; unbekannte Gebührenarten, Zahlende/Empfänger und Provisionsanteile bleiben offen. Nachträgliche Zuordnung oder Aufteilung erhält den originalen Portalbetrag und verhindert doppelte Summierung. Fehlende rein interne Kostenanalyse blockiert nicht ohne Weiteres den vertraglichen Aufenthalt. Siehe [[K01_Preisstruktur_und_Abrechnung|K01]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]] · [[R00_Szenarien/R01_Eigene_Webseite|A1 – Eigene Webseite]] · [[R00_Szenarien/R08_Destination_Solutions|A3 – Destination Solutions]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A4 – FeWo-direkt]] · [[00_Portalprofile_und_Vertragsvorlagen|Vertragsprofile]] · [[G00_Gates_und_Uebergaben|Gates]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
--- v0.7/00_Portalprofile_und_Vertragsvorlagen.md
+++ v0.8/00_Portalprofile_und_Vertragsvorlagen.md
@@ -3,7 +3,7 @@
typ: fachliches-konzept
titel: Portalprofile, Konditionsquellen und Vertragsvorlagen
status: diskussionsentwurf
-version: "0.2"
+version: "0.3"
stand: 2026-10-31
prozess: V01
bezugsstand_archetypen: "0.6"
@@ -66,7 +66,7 @@
- Zahlung nach aktuellem Ablauf über FeWo-direkt. Vertragsdokumentation und lokale Gästebetreuung bei uns; Storno-/Mahnverantwortung ist noch genauer zu prüfen.
- Die heutige FeWo-direkt-Vertragsvorlage ist **ein spezielles Dokumentenprofil**, kein globaler Vertragsstandard.
-Siehe [A04 – Analyse der bisherigen FeWo-direkt-Vertragsvorlage](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md).
+Siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 – Analyse der bisherigen FeWo-direkt-Vertragsvorlage]].
## 7. Bewusste Grenzen / offene Punkte
@@ -101,4 +101,8 @@
- **FeWo-direkt (A4):** Eigene Miet-/Rabatt-/Stornokonfiguration im Portal; im Vermieterposteingang sind bei einer Buchung einzelne Summen, Zahlungsraten und erwartete Auszahlung ersichtlich, nicht notwendigerweise die Einzelpreiszerlegung. Eigener statischer Mietvertrag bislang nicht im Inserat hinterlegt. Angeblich/öffentlich angebotene Funktionen sind nicht automatisch im konkreten Betreiberkonto vorhanden.
- **Destination Solutions (A3):** Extern bereits verbindliche Buchung; danach vollständige Abwicklung beim Vermieter. **In aktuellem Betreiberzugang keine Kalendersynchronisation**; manuelle Portalsperrung mit begrenzter Nachweisbarkeit. Provision kann nach Vertriebskanal differieren; Gast-Serviceaufschlag, Preisaufschläge und vorvertragliche Anzeige der Stornobedingungen sind noch ungeklärt.
-Details: [K01 Preise & Abrechnung](K01_Preisstruktur_und_Abrechnung.md); [R08 Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md); [O00 offene Fragen](O00_Offene_Portalprueffaelle.md).
+Details: [[K01_Preisstruktur_und_Abrechnung|K01 Preise & Abrechnung]]; [[R00_Szenarien/R08_Destination_Solutions|R08 Destination Solutions]]; [[O00_Offene_Portalprueffaelle|O00 offene Fragen]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Buchungsarchetypen|Archetypen]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02 Vertragsverbindlichkeit]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Vertragsabwicklung]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]] · [[O00_Offene_Portalprueffaelle|Offene Fragen]]
--- v0.7/00_Prozesslandkarte.md
+++ v0.8/00_Prozesslandkarte.md
@@ -3,10 +3,10 @@
typ: prozesslandkarte
titel: FewoPortal – Prozesslandkarte
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
-# 00 – Prozesslandkarte FewoPortal v0.7
+# 00 – Prozesslandkarte FewoPortal v0.8
**Status:** gemeinsamer Arbeitsstand; übergreifendes Modell, nicht vollständig freigegeben.
**Stand:** 31.10.2026
@@ -125,4 +125,8 @@
**Nachträgliche Ereignisse (E-019):** Änderungsanfrage, bestätigte Änderung, Stornierungswunsch und wirksame Stornierung unterscheiden. Ursache, Durchführender, vertragliche Folgen, Belegung und Geldflüsse getrennt dokumentieren.
-**Zu vertiefen:** [K01 Preis- und Abrechnungsmodell](K01_Preisstruktur_und_Abrechnung.md), [X01 Belegungskonflikt- und Sperrnachweise](X01_Belegungskonflikte_und_Sperrnachweise.md), [O00 offene Portalfragen](O00_Offene_Portalprueffaelle.md).
+**Zu vertiefen:** [[K01_Preisstruktur_und_Abrechnung|K01 Preis- und Abrechnungsmodell]], [[X01_Belegungskonflikte_und_Sperrnachweise|X01 Belegungskonflikt- und Sperrnachweise]], [[O00_Offene_Portalprueffaelle|O00 offene Portalfragen]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01 Buchungseingang]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02 Konditionen und Bindung]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Verwaltung und Abwicklung]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04 Aufenthalt]] · [[P05/P05_Abschluss_und_Nachbereitung|P05 Abschluss]] · [[G00_Gates_und_Uebergaben|Gates]] · [[S00_Supportprozesse|Supportprozesse]] · [[X00_Sonderprozesse|Sonderprozesse]] · [[00_Buchungsarchetypen|Archetypen]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
--- v0.7/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md
+++ v0.8/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md
@@ -3,7 +3,7 @@
typ: prozessanalyse
titel: FeWo-direkt – Vertragsvorlage und Einordnung in den A4-Istprozess
status: diskussionsentwurf
-version: "0.5"
+version: "0.6"
stand: 2026-10-31
prozess: V01
archetyp: A4
@@ -81,7 +81,7 @@
**Welche Konditionen sieht und bestätigt der Gast bei einer konkreten FeWo-direkt-Direktbuchung und welche Dokumente erhält er anschließend tatsächlich vom Portal?**
-Der nachträgliche eigene Mietvertrag ist **nicht** vorab hinterlegt. Ein extern zu prüfender Beispielbuchungsablauf bzw. belegbarer Buchungsauszug soll die tatsächlichen Konditionen und Dokumente identifizieren; die Buchung bleibt schon vor unserer Datennachforderung verbindlich, soweit der Portalabschluss dies belegt. Auf Basis dieser Feststellung wird je Kanal die passende **versionierte eigene Vertrags-/Dokumentenvorlage** zugeordnet. Siehe [Portalprofile und Vertragsvorlagen](00_Portalprofile_und_Vertragsvorlagen.md).
+Der nachträgliche eigene Mietvertrag ist **nicht** vorab hinterlegt. Ein extern zu prüfender Beispielbuchungsablauf bzw. belegbarer Buchungsauszug soll die tatsächlichen Konditionen und Dokumente identifizieren; die Buchung bleibt schon vor unserer Datennachforderung verbindlich, soweit der Portalabschluss dies belegt. Auf Basis dieser Feststellung wird je Kanal die passende **versionierte eigene Vertrags-/Dokumentenvorlage** zugeordnet. Siehe [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile und Vertragsvorlagen]].
## 6. Öffentliche Quellen für die juristisch-technischen Prüfpunkte
@@ -167,4 +167,8 @@
4. **Sonderprozesse:** Bisher keine konkret selbst durchlaufene FeWo-direkt-Buchungsänderung und keine eigene Vermieterstornierung. Kein nicht erprobtes Verfahren als gelebte Praxis behaupten. Differenzierung **tatsächliche Stornoursache, Antragsteller, ausführender Beteiligter** beachten.
5. **Abrechnung:** Unbekannte Gast-Servicegebühren, Portalabzüge, Vermieterprovisionen oder kombinierte Sammelpositionen müssen nicht künstlich zerlegt werden. Portalinformationen und manuelle Ergänzungen mit Quelle sichern; bei abweichenden Summen Klärungsaufgabe.
-Fachliche Konkretisierung: [K01](K01_Preisstruktur_und_Abrechnung.md), [X01](X01_Belegungskonflikte_und_Sperrnachweise.md) und [O00](O00_Offene_Portalprueffaelle.md). Keine Aktualisierung oder juristische Freigabe des ursprünglichen PDF-Vertrags durch diese Analyse.
+Fachliche Konkretisierung: [[K01_Preisstruktur_und_Abrechnung|K01]], [[X01_Belegungskonflikte_und_Sperrnachweise|X01]] und [[O00_Offene_Portalprueffaelle|O00]]. Keine Aktualisierung oder juristische Freigabe des ursprünglichen PDF-Vertrags durch diese Analyse.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Buchungsarchetypen|Archetypen]] · [[00_Portalprofile_und_Vertragsvorlagen|Vertragsprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[O00_Offene_Portalprueffaelle|Offene Prüffälle]] · [[P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse_historisch|Frühere Fassung im P03-Archiv]]
--- v0.7/AENDERUNGSNOTIZ.md
+++ v0.8/AENDERUNGSNOTIZ.md
@@ -1,3 +1,11 @@
+---
+id: CHANGE-NOTE
+typ: dokumentationshilfe
+titel: "Änderungsnotiz"
+status: arbeitsstand
+version: "0.1"
+---
+
# Änderungsnotiz – Portalprofile und Vertragsvorlagen (31.10.2026)
- `00_Buchungsarchetypen.md`: v0.2 → v0.3, **Abschnitt 7 neu**, frühere Abschnitte 7/8 nur umnummeriert; bestehende Archetypen/Gates unverändert.
@@ -5,3 +13,7 @@
- `00_Portalprofile_und_Vertragsvorlagen.md`: **neu** v0.1, portable Portal-/Buchungstyp-/Herkunftsprofile, zugehörige Vertragsvorlagen/Anlagen, Konditionsquellen, Snapshot/Gates.
**Keine Produktivänderungen, kein Code.** Dateien für manuelle Übernahme in bestehende Gitea-Dokumentation; Repository-Stand konnte nicht gegen Gitea selbst verglichen werden. Änderungen vor Übernahme gegen aktuelle Git-Dateien prüfen.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[AENDERUNGSUEBERSICHT|Änderungsübersicht]]
--- v0.7/AENDERUNGSUEBERSICHT.md
+++ v0.8/AENDERUNGSUEBERSICHT.md
@@ -1,3 +1,11 @@
+---
+id: CHANGELOG
+typ: dokumentationshilfe
+titel: "Änderungshistorie"
+status: arbeitsstand
+version: "0.1"
+---
+
# Änderung v0.6 gegenüber v0.5
- **E-011 bestätigt:** Alternative fachliche Endergebnisse von V01: regulär abgeschlossen, ohne Buchung beendet, storniert (nach Verbindlichkeit). Keine zusätzlichen Buchungsworkflows.
@@ -17,3 +25,17 @@
- Neues Portalfragenregister und verbindliche Dokumentationsarbeitsregel: aktuelle Originaldokumente künftig **vor jedem Edit erneut anfordern**.
- R01-Referenzentwurf inhaltlich unverändert übernommen, R08 neu ergänzt.
- Ausgangsdokumente unverändert gelassen; Diff und Prüfliste im Paket. Keine Gitea-Änderung/Implementierungsfreigabe.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[D00_Dokumentationsregel_und_Uebergabe|Dokumentationsregeln]] · [[QUELLENMANIFEST|Quellenmanifest]]
+
+# Änderung v0.8 gegenüber v0.7 – Obsidian-Verknüpfungen (31.10.2026)
+
+- Ausgangspunkt: vom Betreiber erneut hochgeladene vollständige ZIP-Fassung „v0.7 komplett.zip“. Keine Übernahme einer unbestätigten Gitea-Version behauptet.
+- Interne relative Markdown-Links in eindeutige Obsidian-Wikilinks mit Vault-relativen Pfaden umgewandelt; externe Quellen-URLs unverändert.
+- Verknüpfungsnavigation für sämtliche vorhandenen Markdown-Dokumente ergänzt, mit README als Startseite und P01–P05 als zusammenhängendem Phasenpfad.
+- Ein bestehender Verweis auf Abschnitt 7 der FeWo-direkt-Analyse in einen Obsidian-Überschriftenlink umgewandelt.
+- Zwei Dateien mit gleichem Namen und gleicher Dokumenten-ID „A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md“ identifiziert: P03-Unterordnerdatei als historische Fassung eindeutig umbenannt und historischer Identifikator abgesetzt. Die aktuelle kanonische Datei im Root bleibt am ursprünglichen Pfad.
+- **Keine inhaltliche Änderung an den Buchungs-/Vertrags-/Zahlungsentscheidungen**. Die ursprünglichen Änderungs-Diffs zu v0.5–v0.7 bleiben unverändert, ein eigener Diff v0.8 wird ergänzt.
+- Alle Wikilinks und Überschriftenziele programmatisch auf vorhandene Dateien/Abschnitte geprüft.
--- v0.7/D00_Dokumentationsregel_und_Uebergabe.md
+++ v0.8/D00_Dokumentationsregel_und_Uebergabe.md
@@ -3,7 +3,7 @@
typ: arbeitsregel
titel: Dokumentationsregeln, Quellenbasis und Übergabe
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
---
@@ -32,3 +32,13 @@
## Kompakter Kontext für den nächsten Chat
FewoPortal ist eine **kleine, mandantenfähige Vermieterwebsite-/Buchungsanwendung für typischerweise 1–3 Ferienwohnungen je Vermieter, kein Marktplatz**. Ein gemeinsamer Hauptprozess V01 P01–P05, dazu V02 Vermarktung/Gästegewinnung/Gästebindung. Fünf Archetypen: A1 eigene Webseite, A2 externe unverbindliche Anfrage, A3 externe verbindliche Buchung mit weiterer eigener Gesamtabwicklung (**Destination Solutions**), A4 externe verbindliche Buchung mit geteilter Abwicklung (**FeWo-direkt**), A5 überwiegend externe Vollabwicklung. **A6 gestrichen**; Partnerherkunft nur bei Provisionsrelevanz. Ein Vorgang/eine Akte. Externer Preis und beim Vertragsschluss vereinbarte Bedingungen bleiben maßgeblich, spätere Dokumente keine stillen neuen Pflichten. Unterschiedliche/versionierte Vorlagen pro Kanal/Buchungstyp. Portale liefern unterschiedlich vollständige Daten; **manuelle Bearbeitung und Sammel-/Gesamtpreise** sind konstitutive Fachfunktionen. Gast-Mietforderung, externe Gastgebühr, Vermieterprovision, Auszahlung und Zahlung getrennt. Kein Erfinden unbekannter Gebührenanteile. Verfügbarkeit extern nicht garantiert: FeWo-direkt verzögerter iCal-Import, Destination Solutions manuelles Sperren ohne verlässlichen Portal-/Partnernachweis; Doppelbuchungen möglich, deshalb Ausnahmeprozess und Belegkette. Nicht bekannte Vertrags- und Portalfragen im O00-Prüffallregister. **Vor der nächsten Dokumentbearbeitung aktuelle Gitea-Fassung explizit erfragen.**
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[E00_Entscheidungsprotokoll|Entscheidungen]] · [[QUELLENMANIFEST|Quellenmanifest]] · [[AENDERUNGSUEBERSICHT|Änderungshistorie]]
+
+## Technische Dokumentationsregel v0.8 – Obsidian
+
+- Die Dokumentationsbasis wird als Obsidian-Vault genutzt; Querverweise zwischen Markdown-Dateien bevorzugt als eindeutige Wikilinks mit Pfad und Anzeigename erstellen.
+- Nach jeder Dateiänderung interne Links, Überschriftenverweise und vorhandene Zielnotizen prüfen; keine Phantom-Links oder versehentliche Duplikate erzeugen.
+- **Unverändert bindend:** Vor der nächsten Dokumentänderung die dann aktuelle Gitea-Originalfassung beim Betreiber ausdrücklich erneut anfordern.
--- v0.7/E00_Entscheidungsprotokoll.md
+++ v0.8/E00_Entscheidungsprotokoll.md
@@ -3,7 +3,7 @@
typ: entscheidungsprotokoll
titel: Entscheidungsprotokoll
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
# E00 – Entscheidungsprotokoll
@@ -61,4 +61,8 @@
**Nicht beschlossen:** Dass technische Portalprobleme automatisch rechtlich fehlendes Verschulden beweisen; dass eine 10-Minuten-Freigabe heute bei den genannten Portalen möglich ist; dass alle Portale gleiche Preis-/Gast-/Zahlungsdaten bereitstellen; dass nachträglich versandte Stornobedingungen wirksam werden. Solche Aussagen bleiben Prüffälle.
-**Weitere Fachkonzepte:** [Archetypen A1–A5](00_Buchungsarchetypen.md), [Portal-/Vertragsprofile](00_Portalprofile_und_Vertragsvorlagen.md), [Flexible kaufmännische Positionen](K01_Preisstruktur_und_Abrechnung.md), [Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md), [offene Portalprüffälle](O00_Offene_Portalprueffaelle.md).
+**Weitere Fachkonzepte:** [[00_Buchungsarchetypen|Archetypen A1–A5]], [[00_Portalprofile_und_Vertragsvorlagen|Portal-/Vertragsprofile]], [[K01_Preisstruktur_und_Abrechnung|Flexible kaufmännische Positionen]], [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]], [[O00_Offene_Portalprueffaelle|offene Portalprüffälle]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[00_Buchungsarchetypen|Archetypen]] · [[G00_Gates_und_Uebergaben|Gates]] · [[D00_Dokumentationsregel_und_Uebergabe|Dokumentationsregeln]] · [[O00_Offene_Portalprueffaelle|Offene Prüffälle]]
--- v0.7/G00_Gates_und_Uebergaben.md
+++ v0.8/G00_Gates_und_Uebergaben.md
@@ -3,7 +3,7 @@
typ: gate-modell
titel: Gate- und Übergabemodell
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
# G00 – Gate- und Übergabemodell (Arbeitsstand)
@@ -52,3 +52,7 @@
- **X02/X04/X07:** Storno-/Änderungsantrag ist **kein** wirksames Ergebnis. Bei Belegungskonflikt Ursache, zeitliche Abfolge, Bindung beider Buchungen, belegte extern wirksame Sperren und verbleibende Handlungsmöglichkeiten erfassen; Verantwortlichkeit wird nicht aus einem einzigen Button abgeleitet.
**Evidenzstatus je Datenpunkt:** `übermittelt / durch externe Quelle behauptet / anhand Beleg geprüft / intern erfasst / manuell ergänzt / nicht geliefert / widersprüchlich / nicht anwendbar`; als **fachliche Beispiele**, nicht als freigegebene technische Enum. `unbekannt` ist **nicht** `0` oder `nicht vorhanden`.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04]] · [[P05/P05_Abschluss_und_Nachbereitung|P05]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
--- v0.7/K01_Preisstruktur_und_Abrechnung.md
+++ v0.8/K01_Preisstruktur_und_Abrechnung.md
@@ -3,7 +3,7 @@
typ: fachliches-konzept
titel: Preis-, Gebühren- und Abrechnungsinformationen
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
---
@@ -59,7 +59,7 @@
## 6. Reale Prüfbeispiele
-**FeWo-direkt A4 – beobachteter Screenshot, Buchung 10.–17.07.2027:** 840,00 € Übernachtungen, −42,00 € Rabatt, +181,51 € „Gebühren und Steuern“, 979,51 € Gastgesamtbetrag, −84,82 € „An FeWo-direkt gezahlt“, 894,69 € ausgewiesene Gesamtauszahlung. In anderer Ansicht 900,20 € erwartete Auszahlung (5,51 € Differenz). Sichtbarer Zahlungsplan 390,61 € bezahlt und 588,90 € später fällig. **Keine belegte Zerlegung** von 181,51 €/84,82 € oder der 5,51-€-Differenz; einzelne Tagespreise fehlen. Siehe [A04 Abschnitt 7](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md).
+**FeWo-direkt A4 – beobachteter Screenshot, Buchung 10.–17.07.2027:** 840,00 € Übernachtungen, −42,00 € Rabatt, +181,51 € „Gebühren und Steuern“, 979,51 € Gastgesamtbetrag, −84,82 € „An FeWo-direkt gezahlt“, 894,69 € ausgewiesene Gesamtauszahlung. In anderer Ansicht 900,20 € erwartete Auszahlung (5,51 € Differenz). Sichtbarer Zahlungsplan 390,61 € bezahlt und 588,90 € später fällig. **Keine belegte Zerlegung** von 181,51 €/84,82 € oder der 5,51-€-Differenz; einzelne Tagespreise fehlen. Siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A04 Abschnitt 7]].
**Destination Solutions A3 – Betreiberangaben:** Extern bestätigter Buchungspreis ist zu übernehmen und Zahlung durch Vermieter abzuwickeln. Provisionssatz kann nach vermittelndem Partner variieren. Ob Partnerportal den Endpreis erhöht oder eine separate Gast-Servicegebühr erhebt, ist derzeit nicht bestätigt; auch dort darf nur ein übermittelter Gesamtpreis zulässig sein. Keine nachträgliche Provisionsbelastung des Gastes.
@@ -70,4 +70,8 @@
- Welche Vereinbarungen gelten für Stornokostenbasis („Mietpreis“ vs. Gesamtbetrag; inkludierte/ausgeschlossene Leistungen), wenn nur eine Gesamtsumme vorliegt?
- Welche individuellen Portalberichte, tatsächlichen Zahlungsnachweise und Importformate stehen zur Verfügung?
-**Fachliche Herkunft:** Betreiberinterview vom 31.10.2026, FeWo-direkt-Screenshots, [E00 E-014–E-020](E00_Entscheidungsprotokoll.md). Rechtliche Gestaltung separat prüfen.
+**Fachliche Herkunft:** Betreiberinterview vom 31.10.2026, FeWo-direkt-Screenshots, [[E00_Entscheidungsprotokoll|E00 E-014–E-020]]. Rechtliche Gestaltung separat prüfen.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt]]
--- v0.7/O00_Offene_Portalprueffaelle.md
+++ v0.8/O00_Offene_Portalprueffaelle.md
@@ -3,7 +3,7 @@
typ: prueffallregister
titel: Portalbezogene Prüf- und Klärungsfälle
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
---
@@ -46,4 +46,8 @@
Pro Portal idealerweise **ein vollständig anonymisierter realer Buchungsfall**, Gast-Buchungsbestätigung soweit vorhanden, Betreiber-Provisionsabrechnung, Preis-/Stornokonfiguration und ein Beispiel für Änderung/Stornierung. **Nicht alle Nachweise müssen jetzt vorliegen**; Fehlen führt zu manuellen Aufgaben oder offenen Informationsfeldern, nicht zum Erfinden von Regeln.
-**Referenzen:** [Portalprofil K00](00_Portalprofile_und_Vertragsvorlagen.md), [Preisstruktur K01](K01_Preisstruktur_und_Abrechnung.md), [FeWo-direkt A04](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md), [Destination Solutions R02](R00_Szenarien/R08_Destination_Solutions.md).
+**Referenzen:** [[00_Portalprofile_und_Vertragsvorlagen|Portalprofil K00]], [[K01_Preisstruktur_und_Abrechnung|Preisstruktur K01]], [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt A04]], [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions R02]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
--- v0.7/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
+++ v0.8/P01/P01_Buchungseingang_und_Verfuegbarkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungseingang und Verfügbarkeitssicherung
status: entwurf
-version: '0.7'
+version: "0.8"
---
# P01 – Buchungseingang und Verfügbarkeitssicherung
@@ -38,4 +38,8 @@
- **Portalunabhängig:** Art des Belegungs-Inputs (iCal, API, E-Mail, manuell), Ausführungspfad (automatisch/manuell/hybrid), Verzögerung/Unsicherheit und Kontrollmöglichkeiten im Portalprofil hinterlegen. Neue, extern **bereits verbindliche** Kollisionsbuchung als Konflikt behandeln; keine stillschweigende Ablehnung oder Löschung.
- **Drei Sperrzustände:** `Sperrung veranlasst`, `im Zielportal sichtbar`, `nachweislich im relevanten Vertrieb wirksam`. Fehlender Nachweis bleibt **unbekannt**. Für eigene Holds eigene atomare Freihaltung und Sicherung des bindenden Angebots prüfen, ohne fremde Echtzeitwirkung zu versprechen.
-Siehe [X01 – Konfliktmanagement und Nachweise](../X01_Belegungskonflikte_und_Sperrnachweise.md).
+Siehe [[X01_Belegungskonflikte_und_Sperrnachweise|X01 – Konfliktmanagement und Nachweise]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|Weiter zu P02]] · [[G00_Gates_und_Uebergaben|Gates]] · [[X01_Belegungskonflikte_und_Sperrnachweise|X07 Belegungskonflikte]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]]
--- v0.7/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
+++ v0.8/P02/P02_Konditionen_und_Buchungsverbindlichkeit.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Konditionen und Buchungsverbindlichkeit
status: entwurf
-version: '0.7'
+version: "0.8"
---
# P02 – Konditionen und Buchungsverbindlichkeit
@@ -58,4 +58,8 @@
- **Vorvertragliche Einbeziehung:** Ob dem Gast vor Abschluss Stornostaffeln, Pflichtgebühren und sonstige Bedingungen angezeigt wurden, ist je Portal zu prüfen; ein nachträgliches Dokument erzeugt nicht automatisch neue Vertragspflichten.
- **Destination Solutions:** Genannte Stornostaffel (vom Betreiber berichtet): mindestens 60 Tage vorher 0 %, 59–45 Tage 35 %, 44–33 Tage 50 %, 32–22 Tage 70 %, 21–12 Tage 90 %, 11 Tage oder weniger 100 % des „Mietpreises“. **Ungeklärt:** Nachweis im Buchungsprozess, Durchsetzbarkeit, genaue Kostenbasis. Nicht als globalen A3-Standard verwenden.
-Siehe [K00](../00_Portalprofile_und_Vertragsvorlagen.md), [K01](../K01_Preisstruktur_und_Abrechnung.md) und [R08 Destination Solutions](../R00_Szenarien/R08_Destination_Solutions.md).
+Siehe [[00_Portalprofile_und_Vertragsvorlagen|K00]], [[K01_Preisstruktur_und_Abrechnung|K01]] und [[R00_Szenarien/R08_Destination_Solutions|R08 Destination Solutions]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|Zurück zu P01]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|Weiter zu P03]] · [[G00_Gates_und_Uebergaben|Gates]] · [[00_Portalprofile_und_Vertragsvorlagen|Vertragsprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]]
--- v0.7/P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md
+++ v0.8/P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse_historisch.md
@@ -1,9 +1,9 @@
---
-id: A04-DOK-01
+id: A04-DOK-ARCHIV
typ: prozessanalyse
titel: FeWo-direkt – Vertragsvorlage und Einordnung in den A4-Istprozess
status: diskussionsentwurf
-version: "0.2"
+version: "0.3"
stand: 2026-10-31
prozess: V01
archetyp: A4
@@ -12,7 +12,9 @@
- "Betreiberbeschreibung: manueller A4-Istprozess, 31.10.2026"
---
-# A4 – Vertragsvorlage und Prozessanalyse
+> **Historischer Bearbeitungsstand (ursprünglich v0.2)** – für die aktuelle Analyse siehe [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A4 – aktuelle Hauptfassung]].
+
+# A4 – Vertragsvorlage und Prozessanalyse (historische Fassung)
> **Arbeitsdokument, keine Freigabe zur Änderung rechtlicher Klauseln.** Die Vertragsvorlage ist ein Beispiel für den aktuellen Ablauf, kein Nachweis der beim Buchungsabschluss über FeWo-direkt tatsächlich akzeptierten Konditionen. **Zugangscodes, Passwörter, persönliche Kontaktdaten und Namen von Gästen werden hier bewusst nicht reproduziert.**
@@ -81,7 +83,7 @@
**Welche Konditionen sieht und bestätigt der Gast bei einer konkreten FeWo-direkt-Direktbuchung und welche Dokumente erhält er anschließend tatsächlich vom Portal?**
-Der nachträgliche eigene Mietvertrag ist **nicht** vorab hinterlegt. Ein extern zu prüfender Beispielbuchungsablauf bzw. belegbarer Buchungsauszug soll die tatsächlichen Konditionen und Dokumente identifizieren; die Buchung bleibt schon vor unserer Datennachforderung verbindlich, soweit der Portalabschluss dies belegt. Auf Basis dieser Feststellung wird je Kanal die passende **versionierte eigene Vertrags-/Dokumentenvorlage** zugeordnet. Siehe [Portalprofile und Vertragsvorlagen](00_Portalprofile_und_Vertragsvorlagen.md).
+Der nachträgliche eigene Mietvertrag ist **nicht** vorab hinterlegt. Ein extern zu prüfender Beispielbuchungsablauf bzw. belegbarer Buchungsauszug soll die tatsächlichen Konditionen und Dokumente identifizieren; die Buchung bleibt schon vor unserer Datennachforderung verbindlich, soweit der Portalabschluss dies belegt. Auf Basis dieser Feststellung wird je Kanal die passende **versionierte eigene Vertrags-/Dokumentenvorlage** zugeordnet. Siehe [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile und Vertragsvorlagen]].
## 6. Öffentliche Quellen für die juristisch-technischen Prüfpunkte
@@ -98,3 +100,7 @@
- [Kühlungsborn – Kurabgabe](https://www.kuehlungsborn.de/kurabgabe/)
**Abgrenzung:** Dies ist eine fachliche Prozess- und Risikoprüfung, keine rechtliche Freigabe und keine eigenmächtige Überarbeitung der Betreiber-Vertragstexte.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|Aktuelle FeWo-direkt-Analyse]]
--- v0.7/P03/P03_Buchungsverwaltung_und_Abwicklung.md
+++ v0.8/P03/P03_Buchungsverwaltung_und_Abwicklung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Buchungsverwaltung und kaufmännische Abwicklung
status: entwurf
-version: '0.7'
+version: "0.8"
---
# P03 – Buchungsverwaltung und kaufmännische Abwicklung
@@ -38,4 +38,8 @@
6. **Destination Solutions A3:** Vermieter führt Vertrag, Zahlungsanforderung, Zahlungskontrolle und ggf. Stornobearbeitung; Höhe der Vermittlerprovision je Herkunft unterschiedlich möglich. Keine zusätzliche Provisionsrechnung an den Gast ohne vorbestehende Vereinbarung.
7. **FeWo-direkt A4:** Sichtbarer Gastzahlungsplan und erwartete Auszahlung ersetzen weder den Beleg über Bankeingang noch vollständige Gebührenaufschlüsselung; siehe konkrete A4-Screenshots und offenen 5,51-€-Differenzfall.
-[Vertiefung: K01](../K01_Preisstruktur_und_Abrechnung.md).
+[[K01_Preisstruktur_und_Abrechnung|Vertiefung: K01]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|Zurück zu P02]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|Weiter zu P04]] · [[K01_Preisstruktur_und_Abrechnung|Preis und Abrechnung]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|Aktuelle FeWo-direkt-Analyse]] · [[P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse_historisch|Historischer FeWo-direkt-Entwurf]]
--- v0.7/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
+++ v0.8/P04/P04_Leistungsvorbereitung_und_Aufenthalt.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Leistungsvorbereitung und Aufenthalt
status: entwurf
-version: '0.7'
+version: "0.8"
---
# P04 – Leistungsvorbereitung und Aufenthalt
@@ -30,3 +30,7 @@
## Ergänzung v0.7: externe Kommunikationszuständigkeit
Bei Portal-Direktbuchungen unterscheiden: Portal kündigt Gastnachricht an, Portalversand ist tatsächlich bestätigt oder Vermieter versendet eigene Informationen. FeWo-direkt kündigt in der gezeigten Buchung eine E-Mail etwa 72 Stunden vor Anreise an; dies ist **noch kein Nachweis**, dass sie dem Gast zugegangen ist. Falls erforderliche Gäste-/Meldedaten fehlen, manuell nachfordern. Bei Destination Solutions führt Vermieter die Gast- und Dienstleisterkommunikation im Rahmen der eigenen Abwicklung.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|Zurück zu P03]] · [[P05/P05_Abschluss_und_Nachbereitung|Weiter zu P05]] · [[G00_Gates_und_Uebergaben|Gates]] · [[S00_Supportprozesse|Supportprozesse]]
--- v0.7/P05/P05_Abschluss_und_Nachbereitung.md
+++ v0.8/P05/P05_Abschluss_und_Nachbereitung.md
@@ -3,7 +3,7 @@
typ: prozessphase
titel: Abschluss und Nachbereitung
status: entwurf
-version: '0.7'
+version: "0.8"
---
# P05 – Abschluss und Nachbereitung
@@ -33,3 +33,7 @@
## Ergänzung v0.7: Abrechnung und Nachweislücken
Eine Buchung darf nach erbrachter Leistung fachlich regulär enden, selbst wenn **Provisionsaufschlüsselung, ausstehende Auszahlung oder ungeklärte Sammelgebühren** in einem gesondert zugewiesenen Folgefall weiterbearbeitet werden. Gastbezogene offene Forderungen, Storno- oder Auszahlungsdifferenzen müssen mit Quelle, Verantwortlichem und Buchungsreferenz nachvollziehbar übergeben werden. Fehlende detaillierte Preisaufteilung ist nicht automatisch eine unvollständige Gastleistung.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|Zurück zu P04]] · [[G00_Gates_und_Uebergaben|Gates]] · [[S00_Supportprozesse|Supportprozesse]]
--- v0.7/QUELLENMANIFEST.md
+++ v0.8/QUELLENMANIFEST.md
@@ -1,3 +1,11 @@
+---
+id: SOURCE-MANIFEST
+typ: dokumentationshilfe
+titel: "Quellenmanifest"
+status: arbeitsstand
+version: "0.1"
+---
+
# QUELLENMANIFEST – FewoPortal v0.7
Erstellt: 2026-10-31. 22 Markdown-Dateien im Paket.
@@ -33,3 +41,7 @@
- R01 / R00 Szenarien: `/mnt/data/FewoPortal_R01_Arbeitsentwurf/R00_Szenarien/`.
- Entscheidungen: Nutzerinterview vom 31.10.2026.
- Gitea-Stand unbekannt und nicht verändert. **Vor weiteren Änderungen aktuelle Originale anfordern.**
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[D00_Dokumentationsregel_und_Uebergabe|Dokumentationsregeln]] · [[E00_Entscheidungsprotokoll|Entscheidungen]]
--- v0.7/R00_Szenarien/00_Szenariomatrix.md
+++ v0.8/R00_Szenarien/00_Szenariomatrix.md
@@ -4,7 +4,7 @@
titel: Buchungsszenarien und Vergleichsfälle
autor: FewoPortal Fachinterview
status: diskussionsentwurf
-version: '0.2'
+version: "0.3"
---
# R00 – Buchungsszenarien und Vergleichsfälle
@@ -13,7 +13,7 @@
| ID | Szenario | Eingang und Bindung | Typische Abweichung | Bearbeitungsstand |
|---|---|---|---|---|
-| R01 | Eigene Webseite | Anfrage → eigenes bindendes Angebot → Annahme | Hold/Angebotsfrist, eigene Zahlung, Kalenderabgleich | **In Diskussion:** [R01](R01_Eigene_Webseite.md) |
+| R01 | Eigene Webseite | Anfrage → eigenes bindendes Angebot → Annahme | Hold/Angebotsfrist, eigene Zahlung, Kalenderabgleich | **In Diskussion:** [[R00_Szenarien/R01_Eigene_Webseite|R01]] |
| R02 | Telefonisch/manuell | Manuell erfasste Anfrage → eigenes Angebot | Eingabe durch Betreiber, Kommunikationskanal | Vorgemerkt |
| R03 | Unverbindliche Portalanfrage | Portal-Anfrage → eigenes Angebot → Annahme | Fehlende Gastdaten, Portal-Kommunikation | Vorgemerkt |
| R04 | Verbindliche Portalbuchung, Vertrag durch uns | Bereits extern verbindlich | Externer bindender Preis, nachträgliche Vertragsdokumentation ohne erneute Annahme, Zahlung je Portal | Vorgemerkt |
@@ -26,4 +26,8 @@
## Ergänzung v0.2: Externe Direktbuchung
-**R08 – Destination Solutions (A3):** Bereits verbindliche Buchung, danach Vertrags-/Zahlungs-/Gastabwicklung durch Vermieter; manuelle Sperre externer Kalender, kein belegter Partner-Sync; unterschiedliche Vermittlerprovisionen je Kanal, zusätzliche Gastgebühren und einzelne Preispositionen derzeit unklar. **A6 entfällt** als Archetyp. [R08 Referenzfall](R08_Destination_Solutions.md).
+**R08 – Destination Solutions (A3):** Bereits verbindliche Buchung, danach Vertrags-/Zahlungs-/Gastabwicklung durch Vermieter; manuelle Sperre externer Kalender, kein belegter Partner-Sync; unterschiedliche Vermittlerprovisionen je Kanal, zusätzliche Gastgebühren und einzelne Preispositionen derzeit unklar. **A6 entfällt** als Archetyp. [[R00_Szenarien/R08_Destination_Solutions|R08 Referenzfall]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[00_Buchungsarchetypen|Archetypen]] · [[R00_Szenarien/R01_Eigene_Webseite|R01 – Eigene Webseite]] · [[R00_Szenarien/R08_Destination_Solutions|R08 – Destination Solutions]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|A4 – FeWo-direkt]]
--- v0.7/R00_Szenarien/R01_Eigene_Webseite.md
+++ v0.8/R00_Szenarien/R01_Eigene_Webseite.md
@@ -3,7 +3,7 @@
typ: geschaeftsszenario
titel: Buchung über eigene Webseite – End-to-End-Referenzfall
status: diskussionsentwurf
-version: '0.1'
+version: "0.2"
---
# R01 – Buchung über die eigene Webseite
@@ -65,3 +65,7 @@
## 6. Noch nicht entschieden
Weder genaue Zeitregeln des Holds noch die Konfliktpriorisierung, die Pflichtfelder je Schritt oder der Automatisierungsgrad sind durch dieses Szenariodokument neu entschieden. Dieses Dokument ist ein **Diskussionsentwurf**, der erst nach Betreiberprüfung in die vorhandenen Phasen- und Gate-Dokumente übernommen werden soll.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[R00_Szenarien/00_Szenariomatrix|Szenariomatrix]] · [[00_Buchungsarchetypen|Archetypen]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01]] · [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04]] · [[P05/P05_Abschluss_und_Nachbereitung|P05]]
--- v0.7/R00_Szenarien/R08_Destination_Solutions.md
+++ v0.8/R00_Szenarien/R08_Destination_Solutions.md
@@ -3,7 +3,7 @@
typ: geschaeftsszenario
titel: Verbindliche Direktbuchung – Destination Solutions
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
---
@@ -58,4 +58,8 @@
- **Bestätigt aus dem Betreiberinterview:** verbindliche Buchungsübermittlung, komplette weitere Vermieterabwicklung, manuelle Sperre ohne Bestätigungsbeleg, unterschiedliche Vermittlerprovisionen je Partner, Stornostaffel als genannte Vertragsbedingung.
- **Nicht verifiziert:** konkrete Ansicht/Bestätigung des Gastes, Vertragseinbeziehung der Stornoregeln, zusätzliche Gastgebühren oder Aufschläge, Preisaufschlüsselung, verwendete Destination-Solutions-Vertragsvariante, technische Verteilung/Protokollierung.
-- Weitere Nachweise erforderlich: [O00](../O00_Offene_Portalprueffaelle.md).
+- Weitere Nachweise erforderlich: [[O00_Offene_Portalprueffaelle|O00]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[R00_Szenarien/00_Szenariomatrix|Szenariomatrix]] · [[00_Buchungsarchetypen|Archetypen A1–A5]] · [[K01_Preisstruktur_und_Abrechnung|Preisstruktur]] · [[X01_Belegungskonflikte_und_Sperrnachweise|Sperrnachweise]] · [[O00_Offene_Portalprueffaelle|Offene Prüffälle]]
--- v0.7/README.md
+++ v0.8/README.md
@@ -3,15 +3,28 @@
typ: projektindex
titel: FewoPortal Prozessarchitektur
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
-# FewoPortal – Prozessarchitektur v0.7
+# FewoPortal – Prozessarchitektur v0.8
**Status:** Fachlicher Arbeitsstand / Interview, keine Implementierungsfreigabe
**Stand:** 31.10.2026
Diese Konsolidierung führt die Version v0.6 mit **E-011 (alternative fachliche Prozessausgänge)** fort und bewahrt die Betreiberangaben vom 31.10.2026, die v0.3/v0.4, die Entscheidungen E-001 bis E-010 sowie die Übergaben vom 30./31.10.2026. Die **fünf Hauptphasen** dienen als gemeinsames Prozessmodell; ihre Detailregeln sind noch nicht vollständig spezifiziert. **Keine Änderungen am Anwendungscode oder an der produktiven Installation.**
+
+
+## Start in Obsidian – Navigationsübersicht v0.8
+
+Dieses Verzeichnis als **Obsidian-Vault** öffnen. Interne Verweise sind als Obsidian-Wikilinks hinterlegt und verweisen mit Vault-relativen Pfaden auf die vorhandenen Notizen. Die **Prozesslandkarte** dient als fachlicher Ausgangspunkt; Szenarien, Gates und Teilprozesse sind gegenseitig vernetzt.
+
+**Hauptprozess:** [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01 Eingang]] → [[P02/P02_Konditionen_und_Buchungsverbindlichkeit|P02 Bindung]] → [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Abwicklung]] → [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04 Aufenthalt]] → [[P05/P05_Abschluss_und_Nachbereitung|P05 Abschluss]].
+
+**Fachliche Navigation:** [[00_Prozesslandkarte|Prozesslandkarte]] · [[00_Buchungsarchetypen|Archetypen]] · [[R00_Szenarien/00_Szenariomatrix|Szenarien]] · [[G00_Gates_und_Uebergaben|Gates]] · [[S00_Supportprozesse|Support]] · [[X00_Sonderprozesse|Sonderfälle]] · [[E00_Entscheidungsprotokoll|Entscheidungen]].
+
+**Vertiefungen:** [[00_Portalprofile_und_Vertragsvorlagen|Portalprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preis- und Abrechnung]] · [[O00_Offene_Portalprueffaelle|Offene Portalfragen]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt (aktuell)]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]].
+
+> **Dateihistorie:** Die ältere FeWo-direkt-Bearbeitungsfassung wurde aus `P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md` in [[P03/A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse_historisch|P03 – historischer Stand]] umbenannt. So sind beide Fassungen eindeutig adressierbar; die fachlich aktuelle Hauptfassung steht im Vault-Stammverzeichnis.
## Dateien
@@ -34,15 +47,19 @@
**Neue bzw. fortgeschriebene Dateien:**
-- [`00_Buchungsarchetypen.md`](00_Buchungsarchetypen.md) – A1–A5 und reale Referenzfälle
-- [`00_Portalprofile_und_Vertragsvorlagen.md`](00_Portalprofile_und_Vertragsvorlagen.md) – Profile und Vertragstypen
-- [`K01_Preisstruktur_und_Abrechnung.md`](K01_Preisstruktur_und_Abrechnung.md) – Einzel-/Sammel-/Gesamtbeträge, Provisionen, Zahlungsfluss
-- [`A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md`](A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md) – konkrete A4-Beobachtungen und rechtliche Prüffragen
-- [`R00_Szenarien/R01_Eigene_Webseite.md`](R00_Szenarien/R01_Eigene_Webseite.md) – früherer Referenzentwurf, **inhaltlich unverändert**
-- [`R00_Szenarien/R08_Destination_Solutions.md`](R00_Szenarien/R08_Destination_Solutions.md) – A3 Referenzfall
-- [`X01_Belegungskonflikte_und_Sperrnachweise.md`](X01_Belegungskonflikte_und_Sperrnachweise.md) – X07-Vertiefung
-- [`O00_Offene_Portalprueffaelle.md`](O00_Offene_Portalprueffaelle.md) – spätere Konfigurations- und Nachweispunkte
-- [`D00_Dokumentationsregel_und_Uebergabe.md`](D00_Dokumentationsregel_und_Uebergabe.md) – **Pflicht zur erneuten Dokumentenanforderung vor jedem zukünftigen Edit**
-- [`E00_Entscheidungsprotokoll.md`](E00_Entscheidungsprotokoll.md) – Beschlüsse E-012–E-021
+- [[00_Buchungsarchetypen|`00_Buchungsarchetypen.md`]] – A1–A5 und reale Referenzfälle
+- [[00_Portalprofile_und_Vertragsvorlagen|`00_Portalprofile_und_Vertragsvorlagen.md`]] – Profile und Vertragstypen
+- [[K01_Preisstruktur_und_Abrechnung|`K01_Preisstruktur_und_Abrechnung.md`]] – Einzel-/Sammel-/Gesamtbeträge, Provisionen, Zahlungsfluss
+- [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|`A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md`]] – konkrete A4-Beobachtungen und rechtliche Prüffragen
+- [[R00_Szenarien/R01_Eigene_Webseite|`R00_Szenarien/R01_Eigene_Webseite.md`]] – früherer Referenzentwurf, **inhaltlich unverändert**
+- [[R00_Szenarien/R08_Destination_Solutions|`R00_Szenarien/R08_Destination_Solutions.md`]] – A3 Referenzfall
+- [[X01_Belegungskonflikte_und_Sperrnachweise|`X01_Belegungskonflikte_und_Sperrnachweise.md`]] – X07-Vertiefung
+- [[O00_Offene_Portalprueffaelle|`O00_Offene_Portalprueffaelle.md`]] – spätere Konfigurations- und Nachweispunkte
+- [[D00_Dokumentationsregel_und_Uebergabe|`D00_Dokumentationsregel_und_Uebergabe.md`]] – **Pflicht zur erneuten Dokumentenanforderung vor jedem zukünftigen Edit**
+- [[E00_Entscheidungsprotokoll|`E00_Entscheidungsprotokoll.md`]] – Beschlüsse E-012–E-021
**Quellenintegrität:** v0.6 aus dem originalen ZIP extrahiert, da die entpackte v0.6-Verzeichnisansicht P01–P05 nicht enthielt; ergänzende Dokumente aus ihrem jeweils neuesten im Chat verfügbaren Bearbeitungsstand. **Kein direkter Schreibzugriff auf Gitea; keine Repository-Aktualisierung behauptet.** Vor jeder künftigen Änderung aktuelle Quelldokumente erneut vom Betreiber anfordern.
+
+## Verknüpfungen (Obsidian)
+
+[[00_Prozesslandkarte|Prozesslandkarte]] · [[00_Buchungsarchetypen|Archetypen A1–A5]] · [[R00_Szenarien/00_Szenariomatrix|Szenariomatrix]] · [[G00_Gates_und_Uebergaben|Gates und Übergaben]] · [[00_Portalprofile_und_Vertragsvorlagen|Portal- und Vertragsprofile]] · [[K01_Preisstruktur_und_Abrechnung|Preis und Abrechnung]] · [[E00_Entscheidungsprotokoll|Entscheidungen]] · [[O00_Offene_Portalprueffaelle|Offene Prüffälle]] · [[D00_Dokumentationsregel_und_Uebergabe|Dokumentationsregeln]]
--- v0.7/S00_Supportprozesse.md
+++ v0.8/S00_Supportprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Supportprozesse
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
# S00 – Supportprozesse (vorläufiger Katalog)
@@ -33,3 +33,7 @@
- **S02:** Kalenderverzögerung, manuelle Sperrung und fehlender Bestätigungsbeleg als reale Normalfälle. „Exportiert“ oder „im Portal eingetragen“ ist nicht gleich „partnernetzweit wirksam“.
- **S04/S07:** Kaufmännische **Einzel-, Sammel- und Gesamtbeträge** unterstützen; Gast-Servicegebühr, Vermieterprovision, Preisaufschlag, Rabatte, Zahlung und Auszahlung getrennt, soweit feststellbar. Unbekannte Zusammenhänge bleiben ungeklärt; manueller Abgleich möglich.
- **S05/S06:** unterschiedliche Vertragsvorlagen/Anlagen und Versionen je Buchungsprofil; manuelle Daten-/Dokumentenbeschaffung und Klärungsaufgaben ohne separate Portalsoftware-Workflows.
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03 Abwicklung]] · [[P04/P04_Leistungsvorbereitung_und_Aufenthalt|P04 Aufenthalt]] · [[X00_Sonderprozesse|Sonderprozesse]]
--- v0.7/X00_Sonderprozesse.md
+++ v0.8/X00_Sonderprozesse.md
@@ -3,7 +3,7 @@
typ: prozesskatalog
titel: Sonder- und Ausnahmeprozesse
status: arbeitsstand
-version: '0.7'
+version: "0.8"
---
# X00 – Sonder- und Ausnahmeprozesse (vorläufiger Katalog)
@@ -33,4 +33,8 @@
- **X02/X04:** Zwischen *Anfrage*, *Annahme/Bestätigung*, *wirksamer Vertragsänderung/Stornierung* und *tatsächlichen Finanz-/Belegungsfolgen* unterscheiden. Ursache, Initiator, Ausführender und Verantwortlicher sind keine austauschbaren Felder. Tatsächlicher Vermieterstornogrund bleibt Vermieterstornogrund, selbst wenn ein Gast auf der Portaloberfläche die Aktion ausführt; Portalregeln und rechtliche Wirkungen gesondert prüfen. Der Betreiber hat beim FeWo-direkt-Konto bislang keine solche Änderung oder Vermieterstornierung selbst durchgeführt; unbekannte Prozesse nicht als erprobte Ist-Abläufe ausgeben.
- **X05/X06:** Fehlende Preisdetails, zusammengefasste Service-/Provisionsanteile oder abweichende Auszahlungssummen sind normale Klärungsfälle; manuelle Zuordnung und erneuter Abgleich, ohne Buchungspreis zu überschreiben.
-- **X07:** Bei Destination Solutions manuelle Kalendersperre ohne serverseitig/partnernetzweit bestätigten Sperrnachweis; bei FeWo-direkt verzögerter iCal-Import. Technische Ursache und mögliche Rechts-/Haftungsfolgen getrennt bewerten. [Ausführlicher Fachfall X07](X01_Belegungskonflikte_und_Sperrnachweise.md).
+- **X07:** Bei Destination Solutions manuelle Kalendersperre ohne serverseitig/partnernetzweit bestätigten Sperrnachweis; bei FeWo-direkt verzögerter iCal-Import. Technische Ursache und mögliche Rechts-/Haftungsfolgen getrennt bewerten. [[X01_Belegungskonflikte_und_Sperrnachweise|Ausführlicher Fachfall X07]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[00_Prozesslandkarte|Prozesslandkarte]] · [[X01_Belegungskonflikte_und_Sperrnachweise|X07 Belegungskonflikte]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01]] · [[P03/P03_Buchungsverwaltung_und_Abwicklung|P03]]
--- v0.7/X01_Belegungskonflikte_und_Sperrnachweise.md
+++ v0.8/X01_Belegungskonflikte_und_Sperrnachweise.md
@@ -3,13 +3,13 @@
typ: sonderprozess
titel: Verfügbarkeitsabgleich, Sperrnachweise und Doppelbuchungen
status: diskussionsentwurf
-version: "0.1"
+version: "0.2"
stand: 2026-10-31
---
# X07 – Verfügbarkeitsabgleich, Sperrnachweise und Doppelbuchungen
-**Geltungsbereich:** Alle Buchungsarchetypen und Vertriebskanäle. Das Dokument ist eine Vertiefung von X07 aus [X00](X00_Sonderprozesse.md), kein zusätzlicher Buchungsarchetyp.
+**Geltungsbereich:** Alle Buchungsarchetypen und Vertriebskanäle. Das Dokument ist eine Vertiefung von X07 aus [[X00_Sonderprozesse|X00]], kein zusätzlicher Buchungsarchetyp.
## 1. Reale Ursachen und Grenzen
@@ -38,4 +38,8 @@
Mögliche spätere technische Fähigkeiten: Live-API-Verfügbarkeitsabfrage, atomare Reservierung, Portalbestätigung vor Vertragsschluss, Webhooks/Audit-Logs, automatische Konfliktfrüherkennung. **Aktuell nicht als verfügbar oder implementiert voraussetzen.** Für den MVP zunächst: gut sichtbare Sperraufgaben und revisionsfähige Eigenprotokolle.
-Siehe [P01](P01/P01_Buchungseingang_und_Verfuegbarkeit.md), [E00](E00_Entscheidungsprotokoll.md), [Destination Solutions](R00_Szenarien/R08_Destination_Solutions.md).
+Siehe [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01]], [[E00_Entscheidungsprotokoll|E00]], [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]].
+
+## Verknüpfungen (Obsidian)
+
+[[README|Startseite]] · [[X00_Sonderprozesse|Sonderprozesse]] · [[P01/P01_Buchungseingang_und_Verfuegbarkeit|P01]] · [[R00_Szenarien/R08_Destination_Solutions|Destination Solutions]] · [[A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse|FeWo-direkt]]
File diff suppressed because it is too large. Load diff
@@ -1,19 +0,0 @@
---
id: CHANGE-NOTE
typ: dokumentationshilfe
titel: "Änderungsnotiz"
status: arbeitsstand
version: "0.1"
---
# Änderungsnotiz – Portalprofile und Vertragsvorlagen (31.10.2026)
- `00_Buchungsarchetypen.md`: v0.2 → v0.3, **Abschnitt 7 neu**, frühere Abschnitte 7/8 nur umnummeriert; bestehende Archetypen/Gates unverändert.
- `A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md`: v0.1 → v0.2, Nachtrag zur **tatsächlichen Nicht-Hinterlegung** des Vertrags im Portal und zur **fehlenden Einsicht in Gastunterlagen**; bisher offene Frage präzisiert, übrige Befunde erhalten.
- `00_Portalprofile_und_Vertragsvorlagen.md`: **neu** v0.1, portable Portal-/Buchungstyp-/Herkunftsprofile, zugehörige Vertragsvorlagen/Anlagen, Konditionsquellen, Snapshot/Gates.
**Keine Produktivänderungen, kein Code.** Dateien für manuelle Übernahme in bestehende Gitea-Dokumentation; Repository-Stand konnte nicht gegen Gitea selbst verglichen werden. Änderungen vor Übernahme gegen aktuelle Git-Dateien prüfen.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[AENDERUNGSUEBERSICHT|Änderungsübersicht]]
@@ -1,59 +0,0 @@
---
id: CHANGELOG
typ: dokumentationshilfe
titel: "Änderungshistorie"
status: arbeitsstand
version: "0.9"
---
# Änderung v0.6 gegenüber v0.5
- **E-011 bestätigt:** Alternative fachliche Endergebnisse von V01: regulär abgeschlossen, ohne Buchung beendet, storniert (nach Verbindlichkeit). Keine zusätzlichen Buchungsworkflows.
- Präzisiert in `00_Prozesslandkarte.md`, `E00_Entscheidungsprotokoll.md`, `G00_Gates_und_Uebergaben.md`, `P05/P05_Abschluss_und_Nachbereitung.md` und `X00_Sonderprozesse.md`.
- `README.md` aktualisiert; YAML-Version aller bestehenden Fachdokumente konsistent auf `0.6` gesetzt.
- Offene Detailkriterien und Zustandsübergänge ausdrücklich **nicht** als entschieden dargestellt.
- Keine Löschung bestehender Inhalte, keine Änderung des Anwendungscodes. Gitea selbst wurde nicht verändert.
- `AENDERUNGEN_ZU_V0.6.diff` dokumentiert die tatsächlichen Textänderungen.
# Änderung v0.7 gegenüber v0.6 (Konsolidierung 31.10.2026)
- E-012–E-021 aus dem fachlichen Interview nachgeführt; fünf Archetypen, kein A6.
- Destination Solutions (A3) als realer Referenzfall samt Stornostaffel, manueller Sperre ohne Übernahmenachweis, provisionsabhängigen Partnerkanälen und ungeklärtem Gast-Aufschlag dokumentiert.
- FeWo-direkt (A4) um differenzierte Zahlungsdaten, iCal-Risiko, noch offene Rechts-/Gast- und Gebühreninformationen ergänzt.
- Flexible Preispositionen und Sammelbeträge, manuelle/hybride Klärung und kontrollierbare Nachweiskette in P01–P05, K00/K01, G00, X00 aufgenommen.
- Neues Portalfragenregister und verbindliche Dokumentationsarbeitsregel: aktuelle Originaldokumente künftig **vor jedem Edit erneut anfordern**.
- R01-Referenzentwurf inhaltlich unverändert übernommen, R08 neu ergänzt.
- Ausgangsdokumente unverändert gelassen; Diff und Prüfliste im Paket. Keine Gitea-Änderung/Implementierungsfreigabe.
## Änderung v0.9 gegenüber dem übergebenen v0.8-Stand (01.11.2026)
**Ausgangsbasis:** vom Betreiber erneut bereitgestelltes `Prozessarchitektur 0.7.zip` (Archiv enthält tatsächlich v0.8-Obsidian-Inhalte). Original-Archiv und sämtliche bisherigen historischen Diff-Dateien unverändert erhalten.
**Neue verbindliche Entscheidungen:** E-022–E-028 im [[E00_Entscheidungsprotokoll|Entscheidungsprotokoll]].
- **A6 neu:** Eigenbelegung, private Überlassung (Familie/Freunde), Wartung und sonstige Sperren als sechster Archetyp im gemeinsamen Vorgang; **früherer Partner-Hub-A6 bleibt gestrichen**.
- **Ein Vorgang:** Keine zusätzliche fachliche „Buchungsakte“, keine manuelle Akten-Anlageentscheidung; vorhandene Owner-/Kanalzuordnung bleibt erhalten.
- **Gäste/Leistungen bei A6:** Optionale Gästedaten, Kurabgabe, Wäschepakete, weitere entgeltliche Zusatzleistungen und Zahlungen; reine Sperren überspringen irrelevante Schritte.
- **Vorlagen/Workflows:** Automatische Profilwahl je Vermieter, Objekt, Kanal und Vorgangstyp; Buchungs-/Aufenthalts-/Reservierungsbestätigung oder ggf. keine Gastnachricht.
- **A1/A2:** Eine kanalabhängige Haltefrist (0 oder >0), zwei verschiedene Angebotstexte und Folgeabläufe, keine eigenständige Preisbindefrist im Standard; Jahres-/Saisonpreise statt dynamischem Yield-Management.
- **Restrisiko:** Doppelbuchungen pragmatisch absichern, keine uneinlösbare Garantie für externe iCal-/Partnerportale.
- **Szenario:** [[R00_Szenarien/R07_Eigenbelegung_und_Sperren|R07]] neu als A6-Referenz ausgearbeitet; [[R00_Szenarien/00_Szenariomatrix|Szenariomatrix]] aktualisiert.
- **Obsidian:** Linkziele und doppelte Dateibasis geprüft; ältere gleichnamige FeWo-direkt-Analyse unter P03 zur Eindeutigkeit umbenannt, Inhalt unverändert; [vollständiger Textdiff](AENDERUNGEN_ZU_V0.9.diff) und [[MANIFEST_v0.9|Dateimanifest]] erstellt.
**Fachliche Abgrenzung:** Die bestehenden Detaildokumente zu FeWo-direkt/Destination Solutions und vorangegangenen Entscheidungsständen bleiben erhalten. Rechtliche bzw. technische Klärungsfälle werden nicht als geprüft ausgegeben.
## Verknüpfungen (Obsidian)
[[README|Startseite]] · [[D00_Dokumentationsregel_und_Uebergabe|Dokumentationsregeln]] · [[QUELLENMANIFEST|Quellenmanifest]]
# Änderung v0.8 gegenüber v0.7 – Obsidian-Verknüpfungen (31.10.2026)
- Ausgangspunkt: vom Betreiber erneut hochgeladene vollständige ZIP-Fassung „v0.7 komplett.zip“. Keine Übernahme einer unbestätigten Gitea-Version behauptet.
- Interne relative Markdown-Links in eindeutige Obsidian-Wikilinks mit Vault-relativen Pfaden umgewandelt; externe Quellen-URLs unverändert.
- Verknüpfungsnavigation für sämtliche vorhandenen Markdown-Dokumente ergänzt, mit README als Startseite und P01–P05 als zusammenhängendem Phasenpfad.
- Ein bestehender Verweis auf Abschnitt 7 der FeWo-direkt-Analyse in einen Obsidian-Überschriftenlink umgewandelt.
- Zwei Dateien mit gleichem Namen und gleicher Dokumenten-ID „A04_FeWoDirekt_Vertragsvorlage_Prozessanalyse.md“ identifiziert: P03-Unterordnerdatei als historische Fassung eindeutig umbenannt und historischer Identifikator abgesetzt. Die aktuelle kanonische Datei im Root bleibt am ursprünglichen Pfad.
- **Keine inhaltliche Änderung an den Buchungs-/Vertrags-/Zahlungsentscheidungen**. Die ursprünglichen Änderungs-Diffs zu v0.5–v0.7 bleiben unverändert, ein eigener Diff v0.8 wird ergänzt.
- Alle Wikilinks und Überschriftenziele programmatisch auf vorhandene Dateien/Abschnitte geprüft.
Binary file not shown.

After

Width:  |  Height:  |  Size: 254 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 179 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 219 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 152 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 185 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 453 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 330 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 94 KiB

@@ -1 +0,0 @@
{}
Loaded 100 of 170 files, more files were not shown because too many files have changed in this diff. Show more