Vier Schablonen (Eigenes/Portal-Inkasso, Eigene/Externe Vertragsdokumentation) in app/Process/Templates, TemplateComposer prüft Ergebnisse, Verantwortlichkeiten, Ausschlüsse und harte Modulabhängigkeiten. Der Plan friert die Schablonenversionen ein. A3–A5 bleiben als Voreinstellungen; die vierte Kombination (eigenes Inkasso + externe Unterlagen) ist darstellbar. Konfigurator-Logik und ConfigureChannelProcess kennen die Schablonenwahl. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
173 lines
7.4 KiB
PHP
173 lines
7.4 KiB
PHP
<?php
|
||
|
||
namespace App\Process;
|
||
|
||
use App\Enums\ChannelBookingModel;
|
||
use App\Enums\IntakeKind;
|
||
use App\Enums\ProcessSetting;
|
||
use App\Enums\Responsibility;
|
||
use App\Models\Booking;
|
||
use App\Models\Channel;
|
||
use App\Models\Property;
|
||
use App\Models\Tenant;
|
||
use App\Process\Models\ProcessModel;
|
||
use App\Process\Templates\FunctionTemplate;
|
||
use App\Process\Templates\TemplateComposer;
|
||
|
||
/**
|
||
* Resolves the effective process settings: built-in default → landlord default (tenant) → deviation of the property
|
||
* (expert area) → deviation of the channel for the intake kind. A value that is not set inherits from the level above;
|
||
* a deliberately set 0, "no" or "manual" is a value of its own.
|
||
*/
|
||
class ProcessSettings
|
||
{
|
||
public function resolve(Property $property, ?Channel $channel, IntakeKind $intake): ProcessProfile
|
||
{
|
||
$propertyLevel = (array) ($property->process_overrides ?? []);
|
||
if ($property->contract_template_id !== null) {
|
||
$propertyLevel[ProcessSetting::ContractTemplate->value] = $property->contract_template_id;
|
||
}
|
||
|
||
$levels = [
|
||
ProcessProfile::TENANT => $this->tenantDefaults($property->tenant_id),
|
||
ProcessProfile::PROPERTY => $propertyLevel,
|
||
($channel?->isWebsite() ? ProcessProfile::WEBSITE : ProcessProfile::CHANNEL) => $intake === IntakeKind::Internal || $channel === null ? [] : (array) (($channel->process_overrides ?? [])[$intake->value] ?? []),
|
||
];
|
||
|
||
$values = [];
|
||
$sources = [];
|
||
foreach (ProcessSetting::cases() as $setting) {
|
||
$values[$setting->value] = $setting->default();
|
||
$sources[$setting->value] = ProcessProfile::SYSTEM;
|
||
|
||
foreach ($levels as $level => $settings) {
|
||
if (in_array($level, [ProcessProfile::CHANNEL, ProcessProfile::WEBSITE], true) && ! in_array($intake, $setting->channelIntakes(), true)) {
|
||
continue;
|
||
}
|
||
$value = $setting->normalize($settings[$setting->value] ?? null);
|
||
if ($value !== null) {
|
||
$values[$setting->value] = $value;
|
||
$sources[$setting->value] = $level;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Architektur V2: the process model chosen for the channel and intake kind fixes some settings (e.g. the
|
||
// pre-reservation of the offer model, the responsibilities of A3–A5); these win over every level.
|
||
$model = $this->chosenModel($channel, $intake);
|
||
foreach ($model === null ? [] : $model::fixes() as $key => $fixed) {
|
||
$setting = ProcessSetting::tryFrom($key);
|
||
if ($setting !== null) {
|
||
$values[$key] = $setting->normalize($fixed) ?? $fixed;
|
||
$sources[$key] = ProcessProfile::MODEL;
|
||
}
|
||
}
|
||
|
||
// Function templates chosen for the model's slots fix the responsibility of their area.
|
||
foreach ($this->chosenTemplates($channel, $intake, $model) as $class) {
|
||
foreach ($class::fixes() as $key => $fixed) {
|
||
$values[$key] = $fixed;
|
||
$sources[$key] = ProcessProfile::TEMPLATE;
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
$documents = Responsibility::from((string) $values[ProcessSetting::Documents->value]);
|
||
$payments = Responsibility::from((string) $values[ProcessSetting::Payments->value]);
|
||
|
||
return new ProcessProfile($intake, ProcessProfile::caseTypeFor($intake, $channel?->isPortal() ?? false, $documents, $payments), $values, $sources);
|
||
}
|
||
|
||
/**
|
||
* The function templates in force for the chosen model's slots (chosen ones, otherwise the model's defaults).
|
||
*
|
||
* @return array<string, class-string<FunctionTemplate>>
|
||
*/
|
||
private function chosenTemplates(?Channel $channel, IntakeKind $intake, ?ProcessModel $model): array
|
||
{
|
||
if ($model === null || $model->slots() === []) {
|
||
return [];
|
||
}
|
||
$composer = app(TemplateComposer::class);
|
||
|
||
return $composer->classes($composer->resolve($model, (array) (ProcessPlan::configurationOf($channel, $intake)['templates'] ?? [])));
|
||
}
|
||
|
||
/**
|
||
* The model chosen for the channel and intake kind (Kanal › Ablauf), when it is registered and fits the intake.
|
||
*/
|
||
private function chosenModel(?Channel $channel, IntakeKind $intake): ?ProcessModel
|
||
{
|
||
$key = (string) (ProcessPlan::configurationOf($channel, $intake)['model'] ?? '');
|
||
$catalogue = app(ProcessCatalogue::class);
|
||
if ($key === '' || ! $catalogue->hasModel($key)) {
|
||
return null;
|
||
}
|
||
$model = $catalogue->model($key);
|
||
|
||
return in_array($intake, $model::intakes(), true) ? $model : null;
|
||
}
|
||
|
||
/**
|
||
* Settings of a request from the own website: the website's entry of the channel manager is its channel level
|
||
* (the case itself stays direct, without a channel).
|
||
*/
|
||
public function forWebsite(Property $property, IntakeKind $intake = IntakeKind::Inquiry): ProcessProfile
|
||
{
|
||
return $this->resolve($property, Channel::existingWebsiteOf($property), $intake);
|
||
}
|
||
|
||
/**
|
||
* The settings that would apply to a case right now (its frozen profile is what counts for the case itself).
|
||
*/
|
||
public function forBooking(Booking $booking): ProcessProfile
|
||
{
|
||
// The case's own landlord counts, whichever landlord is current (e.g. a case written by the system).
|
||
$property = $booking->property ?? Property::withoutGlobalScope('tenant')->findOrFail($booking->property_id);
|
||
|
||
$channel = $booking->processChannel() ?? ($booking->source === 'website' ? Channel::existingWebsiteOf($property) : null);
|
||
|
||
return $this->resolve($property, $channel, $booking->intake ?? self::intakeFor($booking));
|
||
}
|
||
|
||
/**
|
||
* Landlord defaults as stored on the tenant (not set: empty).
|
||
*
|
||
* @return array<string, mixed>
|
||
*/
|
||
public function tenantDefaults(?int $tenantId): array
|
||
{
|
||
if ($tenantId === null) {
|
||
return [];
|
||
}
|
||
|
||
return (array) (Tenant::query()->find($tenantId)?->process_defaults ?? []);
|
||
}
|
||
|
||
/**
|
||
* Intake kind of a case that does not name one: a case from a channel that only passes on requests is a request,
|
||
* from other channels a booking that is already binding; everything else (website, phone, e-mail) a request.
|
||
*/
|
||
public static function intakeFor(Booking $booking): IntakeKind
|
||
{
|
||
$channel = $booking->processChannel();
|
||
if ($channel === null || $channel->isWebsite()) {
|
||
return IntakeKind::Inquiry;
|
||
}
|
||
|
||
return $channel->booking_model === ChannelBookingModel::Inquiry ? IntakeKind::Inquiry : IntakeKind::Booking;
|
||
}
|
||
}
|