Geschäftsentscheidungen zuerst (Schablonen je Bereich, Voreinstellungen A3–A5), Einzelschritte eingeklappt, Auswirkungsanalyse beim Schablonenwechsel, unbestätigte Portal-Fähigkeiten gekennzeichnet. Tester-Bericht nennt Schablonen, unabhängig laufende Schritte und fehlende Nachweise; alle vier Kombinationen sind als Szenario getestet. Doku: SCHABLONEN.md. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
156 lines
8.0 KiB
PHP
156 lines
8.0 KiB
PHP
<?php
|
||
|
||
namespace App\Process;
|
||
|
||
use App\Enums\Execution;
|
||
use App\Enums\IntakeKind;
|
||
use App\Models\Channel;
|
||
use App\Process\Modules\ModuleDefinition;
|
||
use App\Process\Templates\TemplateComposer;
|
||
|
||
/**
|
||
* Rule-based comparison of a configuration draft (docs/Prozessarchitektur/MODUL_KONFIGURATIONSMATRIX.md §5): for every
|
||
* step the landlord switched off it names the steps that depend on it, what stays required, the admissible ways to
|
||
* achieve the result otherwise and what the configurator suggests. Derived from the module definitions the runner uses –
|
||
* no second set of rules. Pure: it reads and explains, it never changes a setting.
|
||
*/
|
||
final class ConfigurationImpact
|
||
{
|
||
public function __construct(private ProcessCatalogue $catalogue, private ChannelProcessConfiguration $configuration, private TemplateComposer $composer) {}
|
||
|
||
/**
|
||
* @param array<string, mixed> $draft
|
||
* @return list<array{module: string, label: string, valid: bool, affected: list<string>, relaxed: list<string>, remains: list<string>, alternatives: list<string>, suggestion: string}>
|
||
*/
|
||
public function of(Channel $channel, IntakeKind $intake, array $draft): array
|
||
{
|
||
$rows = collect($this->configuration->preview($channel, $intake, $draft));
|
||
$active = $rows->where('on', true)->pluck('module')->all();
|
||
$labels = $rows->mapWithKeys(fn (array $row): array => [$row['module'] => $row['label']])->all();
|
||
$impacts = [];
|
||
|
||
foreach ($rows as $row) {
|
||
$definition = $this->catalogue->modules()[$row['module']]::definition();
|
||
if (($draft['steps'][$row['module']]['on'] ?? true) !== false) {
|
||
continue;
|
||
}
|
||
$affected = $relaxed = [];
|
||
foreach ($active as $other) {
|
||
foreach ($this->catalogue->modules()[$other]::definition()->requires as $dependency) {
|
||
if ($dependency->module !== $row['module']) {
|
||
continue;
|
||
}
|
||
if ($dependency->hard) {
|
||
$affected[] = $labels[$other];
|
||
} else {
|
||
$relaxed[] = $labels[$other];
|
||
}
|
||
}
|
||
}
|
||
$alternatives = array_values(array_map(fn (Execution $execution): string => $execution->getLabel(), array_filter($definition->executions, fn (Execution $execution): bool => $execution !== Execution::NotRequired)));
|
||
$valid = $definition->isOptional();
|
||
|
||
$impacts[] = [
|
||
'module' => $row['module'], 'label' => $row['label'], 'valid' => $valid,
|
||
'affected' => array_values(array_unique($affected)), 'relaxed' => array_values(array_unique($relaxed)),
|
||
'remains' => $this->remains($definition, $affected, $labels),
|
||
'alternatives' => $alternatives,
|
||
'suggestion' => $this->suggestion($row['label'], $definition, $valid, $alternatives),
|
||
];
|
||
}
|
||
|
||
return $impacts;
|
||
}
|
||
|
||
/**
|
||
* What a change of function templates means (docs/Prozessarchitektur/SCHABLONEN.md): per changed area the modules that
|
||
* drop out, join or stay, the responsibility that changes, the stored switches and settings that no longer apply and
|
||
* what the new template still needs or does not build yet. Compared with the templates in force for new cases. Pure:
|
||
* nothing is changed, nothing is dropped silently – the landlord sees every consequence before saving.
|
||
*
|
||
* @param array<string, mixed> $draft
|
||
* @return list<array{area: string, from: ?string, to: string, removed: list<string>, added: list<string>, kept: list<string>, responsibility: ?array{from: string, to: string}, switches_lost: list<string>, settings_replaced: list<string>, needs: list<string>, extensions: list<string>}>
|
||
*/
|
||
public function ofTemplates(Channel $channel, IntakeKind $intake, array $draft): array
|
||
{
|
||
$model = $this->catalogue->model((string) ($draft['model'] ?? ''));
|
||
if ($model->slots() === []) {
|
||
return [];
|
||
}
|
||
$current = $this->configuration->currentTemplates($channel, $intake);
|
||
$target = $this->composer->resolve($model, (array) ($draft['templates'] ?? []));
|
||
$stored = (array) (($channel->process_overrides ?? [])[$intake->value] ?? []);
|
||
$labelOf = fn (string $module): string => ($this->catalogue->hasModule($module) ? $this->catalogue->modules()[$module]::definition()->label : $module);
|
||
$impacts = [];
|
||
|
||
foreach ($model->slots() as $area) {
|
||
$from = $current[$area->value] ?? null;
|
||
$to = $target[$area->value] ?? null;
|
||
$toClass = $to === null ? null : $this->catalogue->templateClass($to);
|
||
if ($toClass === null || $from === $to) {
|
||
continue;
|
||
}
|
||
$fromClass = $from === null ? null : $this->catalogue->templateClass($from);
|
||
$before = $fromClass === null ? [] : $fromClass::modules();
|
||
$after = $toClass::modules();
|
||
$removed = array_values(array_diff($before, $after));
|
||
$setting = $area->setting();
|
||
$storedValue = $setting->normalize($stored[$setting->value] ?? null);
|
||
|
||
$impacts[] = [
|
||
'area' => $area->label(),
|
||
'from' => $fromClass === null ? null : $fromClass::label(),
|
||
'to' => $toClass::label(),
|
||
'removed' => array_map($labelOf, $removed),
|
||
'added' => array_map($labelOf, array_values(array_diff($after, $before))),
|
||
'kept' => array_map($labelOf, array_values(array_intersect($after, $before))),
|
||
'responsibility' => $fromClass !== null && $fromClass::responsibility() !== $toClass::responsibility()
|
||
? ['from' => $setting->describe($fromClass::responsibility()->value), 'to' => $setting->describe($toClass::responsibility()->value)]
|
||
: null,
|
||
'switches_lost' => array_map($labelOf, array_values(array_filter($removed, fn (string $module): bool => ($stored['steps'][$module]['on'] ?? true) === false))),
|
||
'settings_replaced' => $storedValue !== null && (string) $storedValue !== $toClass::responsibility()->value
|
||
? [$setting->question().' Bisher gespeichert: „'.$setting->describe($storedValue).'“, künftig durch die Schablone: „'.$setting->describe($toClass::responsibility()->value).'“. Der gespeicherte Wert muss beim Speichern ausdrücklich entfernt werden.']
|
||
: [],
|
||
'needs' => array_map(fn (string $result): string => 'Voraussetzung: '.$result, $toClass::requires()),
|
||
'extensions' => $toClass::extensions(),
|
||
];
|
||
}
|
||
|
||
return $impacts;
|
||
}
|
||
|
||
/**
|
||
* The results that stay necessary although the step is off: what the steps depending on it still need.
|
||
*
|
||
* @param list<string> $affected
|
||
* @param array<string, string> $labels
|
||
* @return list<string>
|
||
*/
|
||
private function remains(ModuleDefinition $definition, array $affected, array $labels): array
|
||
{
|
||
$remains = [];
|
||
if ($affected !== []) {
|
||
$remains[] = 'Weiterhin nötig, damit „'.implode('“, „', array_unique($affected)).'“ laufen kann: '.lcfirst($definition->purpose);
|
||
}
|
||
if ($definition->why !== null) {
|
||
$remains[] = $definition->why;
|
||
}
|
||
|
||
return $remains;
|
||
}
|
||
|
||
/**
|
||
* @param list<string> $alternatives
|
||
*/
|
||
private function suggestion(string $label, ModuleDefinition $definition, bool $valid, array $alternatives): string
|
||
{
|
||
if (! $valid) {
|
||
return '„'.$label.'“ ist Pflicht und kann nicht abgeschaltet werden.'.($alternatives !== [] ? ' Zulässig sind stattdessen: '.implode('; ', $alternatives).'.' : '');
|
||
}
|
||
|
||
return $alternatives === []
|
||
? '„'.$label.'“ entfällt ersatzlos; es ist nichts weiter einzustellen.'
|
||
: 'Statt abzuschalten, können Sie „'.$label.'“ auch so erledigen lassen: '.implode('; ', $alternatives).'. Es wird nichts anderes automatisch geändert.';
|
||
}
|
||
}
|