U-A/U-B: Prozesskern mit Fachmodulen, versionierten Modellen, eingefrorenem Prozessplan, ProcessRunner (harte/weiche Abhängigkeiten), CasePricing, Loyalty nur im Tester

CaseActivities/CaseAutomation sind Fassaden über ProcessRunner. Verhaltensvergleich v0.11:
11 Abläufe und 198 Konstellationen gleich, beabsichtigte Abweichungen I-004/I-005 (F-001/F-002).
Volle Suite vor U-B: 785/785.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Opus 5.5 committed 2026-11-04 14:49:44 +01:00
1 parent 98df5e9e3b
commit 7e22e12cac
80 files changed
+4628 -445

No files matched your search

@@ -0,0 +1,116 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Actions\SendBookingDocuments;
use App\Enums\ActivityState;
use App\Enums\ProcessingMode;
use App\Enums\ProcessSetting;
use App\Enums\Responsibility;
use App\Process\Activity;
use App\Process\CaseAutomation;
use App\Process\CaseContext;
use App\Process\Modules\Dependency;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
use App\Process\Modules\RunsAutomatically;
use App\Process\StepResult;
/**
* P03: the binding contract documentation for the guest (booking confirmation with contract, or the documents of a
* portal booking). Who is responsible for it decides the case type (decision O1): ours in A1–A4, the portal's in A5 –
* then the step is shown as external.
*/
final class BookingDocuments extends Module implements RunsAutomatically
{
public static function key(): string
{
return 'documents.send';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Buchungsunterlagen (Vertragsdokumentation)',
purpose: 'Sendet dem Gast die verbindliche Buchungsbestätigung mit Vertrag bzw. die Unterlagen der Portalbuchung.',
phase: 'P03',
requires: [Dependency::hard('guest.details')],
effects: ['case_write', 'guest_mail', 'document'],
waits: ['landlord', 'portal'],
triggers: ['automation', 'booking.taken_over'],
parameters: [ProcessSetting::Documents, ProcessSetting::Processing, ProcessSetting::ContractTemplate],
performers: ['system', 'landlord', 'portal'],
modes: ['automatic', 'manual'],
events: ['document', 'mail'],
readsContractData: true,
);
}
public function applies(CaseContext $case): bool
{
return ! $case->booking->isInternal();
}
public function activities(CaseContext $case): array
{
$booking = $case->booking;
if ($case->profile->documents() === Responsibility::Portal) {
return [new Activity('documents', 'Buchungsunterlagen an den Gast', ActivityState::External)];
}
$binding = $case->binding;
$state = match (true) {
$booking->confirmation_sent_at !== null => ActivityState::Done,
! $binding => ActivityState::Later,
$booking->confirmation_failed_at !== null => ActivityState::Problem,
default => ActivityState::Open,
};
$missing = $binding && $state === ActivityState::Open ? app(CaseAutomation::class)->documentBlockers($booking) : [];
// What the landlord still has to confirm (unreleased texts, terms not shown to be agreed on the portal).
$toConfirm = $binding && $state === ActivityState::Open && $missing === [] ? app(SendBookingDocuments::class)->compose($booking)->toConfirm() : [];
return [new Activity('documents', match (true) {
$state !== ActivityState::Open => $case->inquiry ? 'Buchungsbestätigung mit Vertrag senden' : 'Buchungsunterlagen an den Gast senden',
$case->inquiry => 'Buchungsbestätigung mit Vertrag prüfen und senden',
default => 'Buchungsunterlagen prüfen und senden',
}, $case->later($missing !== [] ? ActivityState::Waiting : $state),
match (true) {
$booking->confirmation_sent_at !== null => 'gesendet am '.$booking->confirmation_sent_at->format('d.m.Y'),
$state === ActivityState::Problem => 'Versand fehlgeschlagen',
$missing !== [] => 'wartet: '.implode(' ', $missing),
$toConfirm !== [] => 'vor dem Versand zu prüfen: '.implode(' ', $toConfirm),
default => null,
}, match (true) {
$state === ActivityState::Problem => 'resendConfirmation',
$binding && $missing === [] && $booking->confirmation_sent_at === null => 'sendDocuments',
default => null,
})];
}
/** The guest's e-mail and the price are what the documents need – not every detail of a request. */
public function due(CaseContext $case): bool
{
$booking = $case->booking;
return $booking->processingMode() === ProcessingMode::Automatic
&& $case->binding && $booking->confirmation_sent_at === null
&& $case->profile->documents() === Responsibility::Landlord && $case->profile->origin !== 'migration';
}
public function blockers(CaseContext $case): array
{
return app(CaseAutomation::class)->documentBlockers($case->booking);
}
public function run(CaseContext $case): StepResult
{
$reasons = app(SendBookingDocuments::class)->automatically($case->booking);
return $reasons === [] ? StepResult::ran() : StepResult::blocked($reasons);
}
public function isOutward(): bool
{
return true;
}
}
@@ -0,0 +1,90 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Availability\AvailabilityChecker;
use App\Enums\ActivityState;
use App\Enums\BookingTaskKind;
use App\Enums\BookingTaskStatus;
use App\Models\BookingTask;
use App\Process\Activity;
use App\Process\CaseContext;
use App\Process\CaseRequirements;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
use App\Process\Modules\StepState;
use Carbon\CarbonImmutable;
/**
* Event-driven work on the case (docs/Prozessarchitektur/Architektur/02 §4.1): every open task – a portal's
* cancellation or change report, a booking wish to decide, conflicting details, payment and service tasks – and the done
* tasks of the stay as its record. Tasks have no fixed place in the course; the model shows them where it lists events.
*/
final class CaseTasks extends Module
{
public static function key(): string
{
return 'case.tasks';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Aufgaben und Meldungen',
purpose: 'Zeigt offene Aufgaben des Vorgangs – Meldungen der Portale, Entscheidungen, Zahlungs- und Leistungsaufgaben.',
phase: 'P03',
effects: ['case_write'],
waits: ['landlord'],
triggers: ['task.created', 'portal.report'],
toggle: ModuleDefinition::TOGGLE_EVENT_DRIVEN,
performers: ['landlord'],
events: ['task'],
);
}
public function activities(CaseContext $case): array
{
return BookingTask::query()->where('booking_id', $case->booking->id)
->where(fn ($query) => $query->where('status', BookingTaskStatus::Open)
->orWhere(fn ($done) => $done->where('status', BookingTaskStatus::Done)->whereIn('kind', [BookingTaskKind::Service, BookingTaskKind::Issue, BookingTaskKind::FollowUp, BookingTaskKind::PayoutCheck, BookingTaskKind::OpenClaim])))
->orderByRaw('due_on is null')->orderBy('due_on')->orderBy('id')->get()
->map(fn (BookingTask $task): Activity => self::task($task))
->all();
}
public function state(CaseContext $case): ?StepState
{
return null;
}
/**
* An open task of the case and the action that settles it.
*/
public static function task(BookingTask $task): Activity
{
$action = match ($task->kind) {
BookingTaskKind::PortalCancellation, BookingTaskKind::PortalCancellationReported => 'confirmPortalCancellation',
BookingTaskKind::PortalChangeReported => 'change',
BookingTaskKind::BookingWish => 'decideWish',
BookingTaskKind::ArrivalDetails => 'arrivalDetails',
BookingTaskKind::CancellationRequest => 'end',
BookingTaskKind::FactConflict => 'provideContact',
default => $task->kind->isPayment() ? null : 'completeTask',
};
$today = CarbonImmutable::today();
$state = match (true) {
$task->status === BookingTaskStatus::Done => ActivityState::Done,
$task->kind === BookingTaskKind::PayoutCheck && $task->due_on?->isAfter($today) => ActivityState::Waiting,
$task->kind === BookingTaskKind::Service && $task->due_on?->isAfter($today) => ActivityState::Later,
$task->kind === BookingTaskKind::BookingWish && $task->booking !== null && ! app(AvailabilityChecker::class)->isAvailable($task->booking->property, $task->booking->arrival, $task->booking->departure, ignore: $task->booking) => ActivityState::Problem,
// v0.11 (B3): the binding confirmation waits for the missing details as well.
$task->kind === BookingTaskKind::BookingWish && $task->booking !== null && CaseRequirements::missing($task->booking, CaseRequirements::WISH_CONFIRMATION) !== [] => ActivityState::Waiting,
default => ActivityState::Open,
};
$detail = $task->status === BookingTaskStatus::Done
? 'erledigt am '.$task->completed_at?->format('d.m.Y').($task->completed_by ? ' von '.$task->completed_by : '').($task->note ? ' · '.$task->note : '')
: trim(($state === ActivityState::Problem ? 'Achtung: Der Zeitraum ist inzwischen belegt – bitte absagen. · ' : '').($task->due_on ? 'fällig '.$task->due_on->format('d.m.Y') : '').($task->responsible ? ' · zuständig: '.$task->responsible : '').($task->note ? ' · '.$task->note : ''), ' ·');
return new Activity('task_'.$task->kind->value, $task->label(), $state, $detail, $state === ActivityState::Done ? null : $action);
}
}
@@ -0,0 +1,53 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Enums\ActivityState;
use App\Enums\ChangeStatus;
use App\Process\Activity;
use App\Process\CaseContext;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
use App\Process\Modules\StepState;
/**
* Event-driven: a change of a binding booking proposed to the guest (ChangeBooking) – shown while it waits for the guest.
*/
final class ChangeProposal extends Module
{
public static function key(): string
{
return 'change.proposal';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Änderungsvorschlag',
purpose: 'Zeigt einen Änderungsvorschlag, der beim Gast liegt.',
phase: 'P03',
effects: ['case_write', 'guest_mail'],
waits: ['guest', 'time'],
triggers: ['change.proposed'],
toggle: ModuleDefinition::TOGGLE_EVENT_DRIVEN,
performers: ['landlord', 'guest'],
events: ['change'],
readsContractData: true,
);
}
public function activities(CaseContext $case): array
{
$activities = [];
foreach ($case->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') : ''));
}
return $activities;
}
public function state(CaseContext $case): ?StepState
{
return null;
}
}
@@ -0,0 +1,65 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Enums\ActivityState;
use App\Enums\BookingStatus;
use App\Process\Activity;
use App\Process\CaseClosure;
use App\Process\CaseContext;
use App\Process\Modules\Dependency;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
/**
* P05 (package 9): the commercial closing – payments, refunds and payouts cleared (CaseClosure::commercialPoints). With
* portal collection only after financial clearance; a portal report of a payout is no proof (decision O5).
*/
final class CommercialSettlement extends Module
{
public static function key(): string
{
return 'case.settlement';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Kaufmännisch abschließen',
purpose: 'Schließt den Vorgang kaufmännisch ab, wenn Zahlungen, Erstattungen und Auszahlungen geklärt sind.',
phase: 'P05',
requires: [Dependency::soft('case.closure')],
effects: ['case_write'],
waits: ['landlord', 'portal'],
triggers: ['payment.recorded', 'stay.closed'],
performers: ['landlord', 'system'],
events: ['settled'],
readsContractData: true,
);
}
public function applies(CaseContext $case): bool
{
$booking = $case->booking;
$settlementApplies = $booking->status === BookingStatus::Completed || $booking->status === BookingStatus::Cancelled;
return $settlementApplies || ($booking->isBinding() && ! $booking->isInternal()) || ($booking->isInternal() && (int) $booking->total > 0);
}
public function activities(CaseContext $case): array
{
$booking = $case->booking;
$settlementApplies = $booking->status === BookingStatus::Completed || $booking->status === BookingStatus::Cancelled;
$points = $settlementApplies && $booking->settled_at === null ? CaseClosure::commercialPoints($booking) : [];
return [new Activity('settlement', 'Kaufmännisch abschließen', match (true) {
$booking->settled_at !== null => ActivityState::Done,
! $settlementApplies => ActivityState::Later,
default => ActivityState::Waiting,
}, match (true) {
$booking->settled_at !== null => 'abgeschlossen am '.$booking->settled_at->format('d.m.Y').($booking->settled_by && $booking->settled_by !== CaseClosure::AUTOMATIC ? ' von '.$booking->settled_by : '').($booking->settled_note ? ' · '.$booking->settled_note : ''),
! $settlementApplies => 'nach dem Aufenthalt, wenn Zahlungen, Erstattungen und Auszahlungen geklärt sind',
default => 'offen: '.implode(' ', $points),
}, $settlementApplies && $booking->settled_at === null && $points !== [] ? 'settle' : null)];
}
}
@@ -0,0 +1,62 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Enums\ActivityState;
use App\Enums\BookingStatus;
use App\Enums\InternalKind;
use App\Models\BookingTask;
use App\Process\Activity;
use App\Process\CaseClosure;
use App\Process\CaseContext;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
/**
* P05 (package 9): closing the stay once nothing is open for it (CaseClosure, overnight or by hand).
*/
final class StayClosure extends Module
{
public static function key(): string
{
return 'case.closure';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Aufenthalt abschließen',
purpose: 'Schließt den Aufenthalt ab, sobald nach der Abreise nichts mehr für ihn offen ist.',
phase: 'P05',
effects: ['case_write'],
waits: ['time', 'landlord'],
triggers: ['schedule:daily'],
performers: ['system', 'landlord'],
events: ['task', 'status', 'settled'],
);
}
public function applies(CaseContext $case): bool
{
return ! $case->closed && ($case->booking->isBinding() || $case->booking->status === BookingStatus::Completed);
}
public function activities(CaseContext $case): array
{
$booking = $case->booking;
$today = $case->today;
$completed = $booking->status === BookingStatus::Completed;
$blockers = $booking->isBinding() && ! $completed ? CaseClosure::stayBlockers($booking) : collect();
return [new Activity('closure', $booking->isInternal() && $booking->internal_kind === InternalKind::Block ? 'Sperrzeit abschließen' : 'Aufenthalt abschließen', match (true) {
$completed => ActivityState::Done,
! $booking->isBinding() || $booking->departure > $today => ActivityState::Later,
default => ActivityState::Waiting,
}, match (true) {
$completed => 'abgeschlossen am '.($booking->completed_at ?? $booking->updated_at)?->format('d.m.Y'),
$blockers->isNotEmpty() => 'wartet auf: '.$blockers->map(fn (BookingTask $task): string => $task->label())->implode(', '),
$booking->isBinding() && $booking->departure <= $today => 'geschieht automatisch über Nacht – oder jetzt von Hand',
default => 'nach der Abreise, sobald nichts mehr für den Aufenthalt offen ist',
}, $booking->isBinding() && ! $completed && $booking->departure <= $today ? 'closeStay' : null)];
}
}
@@ -0,0 +1,47 @@
<?php
namespace App\Process\Modules\Settlement;
use App\Enums\ActivityState;
use App\Enums\InternalKind;
use App\Process\Activity;
use App\Process\CaseContext;
use App\Process\Modules\Module;
use App\Process\Modules\ModuleDefinition;
/**
* A6: an optional stay confirmation for the guests of an own use or private stay (no rental contract).
*/
final class StayConfirmation extends Module
{
public static function key(): string
{
return 'documents.stay_confirmation';
}
public static function definition(): ModuleDefinition
{
return new ModuleDefinition(
label: 'Aufenthaltsbestätigung',
purpose: 'Bestätigt den Gästen einer Eigenbelegung oder privaten Überlassung den Aufenthalt – nur bei Bedarf.',
phase: 'P03',
effects: ['guest_mail', 'document'],
toggle: ModuleDefinition::TOGGLE_OPTIONAL,
performers: ['landlord'],
events: ['document', 'mail'],
);
}
public function applies(CaseContext $case): bool
{
return $case->booking->internal_kind !== InternalKind::Block && filled($case->booking->guest?->email);
}
public function activities(CaseContext $case): array
{
$booking = $case->booking;
return [new Activity('documents', 'Aufenthaltsbestätigung an die Gäste (optional)', $case->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 && ! $case->closed ? 'sendDocuments' : null)];
}
}