$draft * @return list, relaxed: list, remains: list, alternatives: list, 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 $draft * @return list, added: list, kept: list, responsibility: ?array{from: string, to: string}, switches_lost: list, settings_replaced: list, needs: list, extensions: list}> */ 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 $affected * @param array $labels * @return list */ 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 $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.'; } }