Files
laraundfelix/app/Filament/Pages/Webpraesenz.php
T
LarsandClaude Opus 5.5 30dd0f9eb8
CI Feature / test (push) Successful in 1m5s
Deploy Test / test (push) Successful in 59s
Deploy Test / deploy (push) Successful in 24s
Schreibe beim Menüspeichern nur geänderte Einträge
Unveränderte Einträge erhalten höchstens eine neue Reihenfolge; ein bestehender
Gleichstand in Datenbankfolge bleibt unberührt, Texte werden nur bei Änderung
bereinigt. „Website ansehen“ nennt den gespeicherten Stand.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 12:16:27 +01:00

1070 lines
41 KiB
PHP
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<?php
namespace App\Filament\Pages;
use App\Domain\Cms\NavigationItem;
use App\Domain\Cms\Page as CmsPage;
use App\Domain\Cms\PageService;
use App\Domain\Cms\Widgets\Support\SafeUrl;
use App\Filament\Resources\Pages\PageResource;
use App\Filament\Support\Bestand;
use App\Filament\Support\ShowsBestand;
use Filament\Actions\Action;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Pages\Page;
use Filament\Support\Enums\Width;
use Illuminate\Contracts\View\View;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Livewire\Attributes\Url;
use RuntimeException;
/**
* Webpräsenz (Dokument 13, Umbauauftrag Teil C): Seitenbestand und Menüs in einem Arbeitsplatz.
*
* Seiten: gemeinsame Bestandsliste mit Veröffentlichungszustand und Menüzuordnung (gespeicherter Stand).
* Menüs: Arbeitsstand aller Navigationseinträge. Änderungen bleiben offen, bis „Menüänderungen speichern“ sie in
* einem Schritt schreibt; geprüft wird nach den bisherigen Regeln der Navigationsverwaltung. Keine neue Versionierung.
*/
class Webpraesenz extends Page
{
use ShowsBestand;
/** Menübereiche in fester Reihenfolge; Schlüssel wie NavigationItem::PLACEMENTS. */
public const BEREICHE = [
'header' => 'Hauptmenü',
'footer' => 'Fußbereich: Service',
'footer_contact' => 'Fußbereich: Kontakt',
'footer_legal' => 'Fußbereich: Rechtliches',
];
protected static ?string $navigationLabel = 'Website';
protected static ?string $slug = 'webpraesenz';
protected static ?string $title = 'Webpräsenz';
protected static ?int $navigationSort = 20;
protected string $view = 'filament.cms.webpraesenz';
#[Url(as: 'bereich', except: 'seiten')]
public string $register = 'seiten';
#[Url(as: 'suche', except: '')]
public string $suche = '';
#[Url(as: 'zustand', except: 'alle')]
public string $zustand = 'alle';
#[Url(as: 'im-menue', except: 'alle')]
public string $imMenue = 'alle';
#[Url(as: 'sortierung', except: 'bearbeitet')]
public string $sortierung = 'bearbeitet';
/** Angezeigter Menübereich. */
#[Url(as: 'menue', except: 'header')]
public string $menue = 'header';
/** Ausgewählter Eintrag (Schlüssel „e{id}“ oder „n{zähler}“ für neue Einträge). */
public ?string $auswahl = null;
/** @var array<string, array{id: ?int, label: string, page_id: ?int, url: string, placement: string, parent: ?string, is_visible: bool}> */
public array $eintraege = [];
/** Globale Reihenfolge der Schlüssel; entspricht sort_order. @var list<string> */
public array $folge = [];
/** Zu entfernende gespeicherte Einträge. @var list<int> */
public array $entfernt = [];
/** Geladener Stand je Eintrag (id => updated_at) zur Erkennung zwischenzeitlicher Speicherungen. @var array<string, string> */
public array $stand = [];
/** Fingerabdruck je Menübereich beim Laden. @var array<string, string> */
public array $geladen = [];
public int $neu = 0;
/** Schmale Anordnung (Entwurf 3) statt Liste mit festem Detailbereich (Entwurf 1); gesetzt nach verfügbarer Breite. */
public bool $schmal = false;
/** Die Menüs wurden seit dem Laden an anderer Stelle gespeichert. */
public bool $konflikt = false;
/** @var array{aktion: string, argument: int|string|null, titel: string, text: string, label: string, gefahr: bool}|null */
public ?array $bestaetigung = null;
/** Eintrag, dessen Ziel gerade gewählt wird. */
public ?string $zielwahl = null;
public string $zielSuche = '';
public static function canAccess(): bool
{
$user = auth()->user();
return $user !== null && $user->can('viewAny', CmsPage::class) && $user->can('viewAny', NavigationItem::class);
}
public function mount(): void
{
$this->register = in_array($this->register, ['seiten', 'menues'], true) ? $this->register : 'seiten';
$this->menue = array_key_exists($this->menue, self::BEREICHE) ? $this->menue : 'header';
$this->ladeMenues();
$this->auswahl = $this->ersterEintrag($this->menue);
}
public function getMaxContentWidth(): Width|string|null
{
return Width::Full;
}
public function getHeader(): ?View
{
return view('filament.cms.webpraesenz-kopf');
}
public function zeigeRegister(string $register): void
{
$this->register = in_array($register, ['seiten', 'menues'], true) ? $register : 'seiten';
}
// ---------------------------------------------------------------------------------------------------------------
// Seiten
// ---------------------------------------------------------------------------------------------------------------
protected function bestandFilterEigenschaften(): array
{
return ['suche', 'zustand', 'imMenue', 'sortierung'];
}
public function resetFilters(): void
{
$this->suche = '';
$this->zustand = 'alle';
$this->imMenue = 'alle';
$this->bestandGrenze = Bestand::SCHRITT;
}
/**
* @return array<string, mixed>
*/
public function bestand(): array
{
$needle = mb_strtolower(trim($this->suche));
$menues = NavigationItem::query()->with('page')->orderBy('sort_order')->orderBy('id')->get();
$zeilen = [];
$seiten = CmsPage::query()->with('latestRevision')->get();
$seiten = match ($this->sortierung) {
'bearbeitet_alt' => $seiten->sortBy([['updated_at', 'asc'], ['id', 'asc']]),
'adresse' => $seiten->sortBy('path', SORT_NATURAL),
'adresse_ab' => $seiten->sortByDesc('path', SORT_NATURAL),
default => $seiten->sortBy([['updated_at', 'desc'], ['id', 'desc']]),
};
foreach ($seiten as $seite) {
$zeile = $this->seitenZeile($seite, $menues);
if ($this->zustand !== 'alle' && ! in_array($this->zustand, $zeile['zustand'], true)) {
continue;
}
if ($this->imMenue !== 'alle' && ! in_array($this->imMenue, $zeile['menue'], true)) {
continue;
}
if ($needle !== '' && ! str_contains(mb_strtolower($zeile['titel'].' '.$zeile['meta']), $needle)) {
continue;
}
$zeilen[] = $zeile;
}
return [
'suche' => ['eigenschaft' => 'suche', 'label' => 'Suche', 'platzhalter' => 'Titel oder Adresse'],
'filter' => [
['eigenschaft' => 'zustand', 'label' => 'Veröffentlichung', 'vorgabe' => 'alle', 'optionen' => [
'alle' => 'Alle Seiten',
'veroeffentlicht' => 'Veröffentlicht',
'entwurf_neuer' => 'Entwurf neuer als öffentlich',
'nur_entwurf' => 'Nur Entwurf, nicht veröffentlicht',
]],
['eigenschaft' => 'imMenue', 'label' => 'Menü', 'vorgabe' => 'alle', 'optionen' => [
'alle' => 'Alle Seiten',
'hauptmenue' => 'Im Hauptmenü sichtbar',
'nicht_hauptmenue' => 'Nicht im Hauptmenü',
'ohne' => 'Ohne Menüeintrag',
]],
],
'sortierung' => ['eigenschaft' => 'sortierung', 'label' => 'Sortierung', 'optionen' => [
'bearbeitet' => 'Zuletzt bearbeitet zuerst',
'bearbeitet_alt' => 'Am längsten unbearbeitet zuerst',
'adresse' => 'Adresse A–Z',
'adresse_ab' => 'Adresse Z–A',
]],
'hinweis' => 'Die Sortierung ordnet nur diese Übersicht; die Reihenfolge der Website-Menüs steht im Register „Menüs“. Menüzuordnungen zeigen den gespeicherten Stand.'
.($this->menuesGeaendert() ? ' Im Register „Menüs“ gibt es ungespeicherte Änderungen.' : ''),
'zeilen' => $zeilen,
'einheit' => ['Seite', 'Seiten'],
'leer' => ['titel' => 'Noch keine Seiten', 'text' => 'Mit „Seite anlegen“ entsteht die erste Seite als Entwurf.'],
];
}
/**
* @param Collection<int, NavigationItem> $menues
* @return array<string, mixed>
*/
private function seitenZeile(CmsPage $seite, Collection $menues): array
{
$neueste = $seite->latestRevision;
$chips = [];
$zustand = [];
if ($seite->published_revision_id === null) {
$chips[] = ['label' => 'Nur Entwurf, nicht veröffentlicht', 'ton' => 'offen'];
$zustand[] = 'nur_entwurf';
} else {
$chips[] = ['label' => 'Veröffentlicht (Revision '.$seite->published_revision_id.')', 'ton' => 'gut'];
$zustand[] = 'veroeffentlicht';
if ($neueste !== null && $neueste->id !== $seite->published_revision_id) {
$chips[] = ['label' => 'Entwurf neuer', 'ton' => 'offen'];
$zustand[] = 'entwurf_neuer';
}
}
$eintraege = $menues->filter(fn (NavigationItem $item): bool => $item->page_id === $seite->id
|| ($item->page_id === null && $item->targetPath() === $seite->path));
$sichtbarImKopf = false;
foreach ($eintraege as $item) {
$bereich = self::BEREICHE[$item->placement] ?? $item->placement;
$chips[] = ['label' => $bereich.($item->is_visible ? '' : ' · ausgeblendet'), 'ton' => $item->is_visible ? 'neutral' : 'leise'];
$sichtbarImKopf = $sichtbarImKopf || ($item->placement === 'header' && $item->is_visible);
}
if ($eintraege->isEmpty()) {
$chips[] = ['label' => 'Ohne Menüeintrag', 'ton' => 'leise'];
}
$hinweise = ['Zuletzt bearbeitet '.$seite->updated_at?->timezone('Europe/Berlin')->format('d.m.Y H:i')];
if ($seite->published_revision_id !== null && ! $eintraege->contains(fn (NavigationItem $item): bool => $item->is_visible)) {
$hinweise[] = 'Ohne sichtbaren Menüeintrag, aber öffentlich über die Adresse erreichbar und in der Sitemap.';
}
$aktionen = [['label' => 'Bearbeiten', 'href' => PageResource::getUrl('edit', ['record' => $seite]), 'icon' => 'stift']];
if ($neueste !== null) {
$aktionen[] = ['label' => 'Vorschau', 'href' => route('pages.preview.devices', $neueste), 'icon' => 'auge', 'neu' => true];
}
if (auth()->user()?->can('create', CmsPage::class)) {
$aktionen[] = ['label' => 'Duplizieren', 'wire' => "mountAction('duplicate', { page: {$seite->id} })"];
}
return [
'schluessel' => 'seite-'.$seite->id,
'titel' => $neueste?->contentTitle() ?: $seite->path,
'meta' => $seite->path,
'symbol' => 'dokument',
'url' => PageResource::getUrl('edit', ['record' => $seite]),
'chips' => $chips,
'hinweise' => $hinweise,
'aktionen' => $aktionen,
'zustand' => $zustand,
'menue' => array_values(array_filter([
$sichtbarImKopf ? 'hauptmenue' : 'nicht_hauptmenue',
$eintraege->isEmpty() ? 'ohne' : null,
])),
];
}
public function duplicateAction(): Action
{
return Action::make('duplicate')
->label('Duplizieren')
->authorize(fn (): bool => auth()->user()?->can('create', CmsPage::class) ?? false)
->modalHeading(fn (array $arguments): string => 'Seite '.(CmsPage::query()->find($arguments['page'] ?? 0)?->path ?? '').' duplizieren')
->modalDescription('Die Kopie ist ein Entwurf unter neuer Adresse. Die Vorlage bleibt unverändert; ein Menüeintrag entsteht nicht.')
->schema([
TextInput::make('path')
->label('Pfad der neuen Seite')
->required()
->maxLength(255)
->helperText('Zum Beispiel /neue-landingpage'),
])
->modalSubmitActionLabel('Duplizieren')
->action(function (array $arguments, array $data, PageService $service): void {
$source = CmsPage::query()->findOrFail($arguments['page'] ?? 0);
try {
$copy = $service->duplicate($source, $data['path'], auth()->user());
} catch (ValidationException $exception) {
throw ValidationException::withMessages(['mountedActions.0.data.path' => $exception->errors()['path'] ?? Arr::flatten($exception->errors())]);
}
$this->redirect(PageResource::getUrl('edit', ['record' => $copy]));
});
}
// ---------------------------------------------------------------------------------------------------------------
// Menüs: Arbeitsstand
// ---------------------------------------------------------------------------------------------------------------
public function ladeMenues(): void
{
$items = NavigationItem::query()->orderBy('sort_order')->orderBy('id')->get();
$this->eintraege = [];
$this->folge = [];
$this->stand = [];
foreach ($items as $item) {
$k = 'e'.$item->id;
$this->eintraege[$k] = [
'id' => $item->id,
'label' => (string) $item->label,
'page_id' => $item->page_id,
'url' => (string) ($item->url ?? ''),
'placement' => (string) $item->placement,
'parent' => $item->parent_id !== null ? 'e'.$item->parent_id : null,
'is_visible' => (bool) $item->is_visible,
];
$this->folge[] = $k;
$this->stand[$k] = (string) $item->getRawOriginal('updated_at');
}
foreach ($this->eintraege as $k => $eintrag) {
if ($eintrag['parent'] !== null && ! isset($this->eintraege[$eintrag['parent']])) {
$this->eintraege[$k]['parent'] = null;
}
}
$this->entfernt = [];
$this->konflikt = false;
$this->resetErrorBag();
$this->geladen = $this->bereichsStaende();
}
/**
* Fingerabdruck je Menübereich: Einträge in Anzeigefolge mit allen Eigenschaften. Unterschiede zeigen, welche
* Bereiche eine Speicherung tatsächlich verändert.
*
* @return array<string, string>
*/
private function bereichsStaende(): array
{
$staende = [];
foreach ($this->folge as $k) {
$e = $this->eintraege[$k];
$staende[$e['placement']][] = [
$e['id'] ?? $k,
trim($e['label']),
$e['page_id'] !== null ? (int) $e['page_id'] : null,
trim($e['url']),
(bool) $e['is_visible'],
$this->elternVon($k),
];
}
return array_map(fn (array $zeilen): string => md5(json_encode($zeilen, JSON_UNESCAPED_UNICODE) ?: ''), $staende);
}
/**
* Bereiche mit ungespeicherten Änderungen, in der festen Reihenfolge der Bereiche.
*
* @return list<string>
*/
public function betroffeneBereiche(): array
{
$jetzt = $this->bereichsStaende();
$bereiche = [];
foreach (array_unique([...array_keys(self::BEREICHE), ...array_keys($jetzt), ...array_keys($this->geladen)]) as $bereich) {
if (($jetzt[$bereich] ?? null) !== ($this->geladen[$bereich] ?? null)) {
$bereiche[] = $bereich;
}
}
return $bereiche;
}
public function menuesGeaendert(): bool
{
return $this->betroffeneBereiche() !== [];
}
public function bereichsName(string $bereich): string
{
return self::BEREICHE[$bereich] ?? $bereich;
}
/** Wirksamer übergeordneter Eintrag: Untermenüs gibt es nur im Hauptmenü. */
public function elternVon(string $k): ?string
{
$e = $this->eintraege[$k] ?? null;
return $e !== null && $e['placement'] === 'header' && $e['parent'] !== null && isset($this->eintraege[$e['parent']]) ? $e['parent'] : null;
}
/**
* @return list<string>
*/
public function kinderVon(string $k): array
{
return array_values(array_filter($this->folge, fn (string $x): bool => $this->elternVon($x) === $k));
}
/**
* Einträge mit derselben Ebene im selben Bereich, in Anzeigefolge.
*
* @return list<string>
*/
public function geschwister(string $k): array
{
$e = $this->eintraege[$k] ?? null;
if ($e === null) {
return [];
}
$eltern = $this->anzeigeElternVon($k);
return array_values(array_filter($this->folge, fn (string $x): bool => $this->eintraege[$x]['placement'] === $e['placement'] && $this->anzeigeElternVon($x) === $eltern));
}
/**
* Eltern in der Anzeige: nur ein Eintrag der obersten Ebene des Hauptmenüs kann Untereinträge zeigen.
*/
private function anzeigeElternVon(string $k): ?string
{
$eltern = $this->elternVon($k);
return $eltern !== null && $this->eintraege[$eltern]['placement'] === 'header' && $this->elternVon($eltern) === null ? $eltern : null;
}
/**
* Menübaum eines Bereichs: oberste Ebene in Folge, darunter die Untereinträge.
*
* @return list<array{k: string, kinder: list<string>}>
*/
public function baum(string $bereich): array
{
$baum = [];
foreach ($this->folge as $k) {
if ($this->eintraege[$k]['placement'] !== $bereich || $this->anzeigeElternVon($k) !== null) {
continue;
}
$baum[] = ['k' => $k, 'kinder' => array_values(array_filter($this->folge, fn (string $x): bool => $this->anzeigeElternVon($x) === $k))];
}
return $baum;
}
public function anzahl(string $bereich): int
{
return count(array_filter($this->eintraege, fn (array $e): bool => $e['placement'] === $bereich));
}
private function ersterEintrag(string $bereich): ?string
{
return $this->baum($bereich)[0]['k'] ?? null;
}
public function zeigeMenue(string $bereich): void
{
if (! array_key_exists($bereich, self::BEREICHE)) {
return;
}
$this->menue = $bereich;
if ($this->auswahl === null || ($this->eintraege[$this->auswahl]['placement'] ?? null) !== $bereich) {
$this->auswahl = $this->ersterEintrag($bereich);
}
}
public function waehle(string $k): void
{
if (! isset($this->eintraege[$k])) {
return;
}
$this->auswahl = $k;
$this->menue = array_key_exists($this->eintraege[$k]['placement'], self::BEREICHE) ? $this->eintraege[$k]['placement'] : $this->menue;
}
public function nachbar(string $k, string $richtung): ?string
{
$geschwister = $this->geschwister($k);
$index = array_search($k, $geschwister, true);
if ($index === false) {
return null;
}
return $geschwister[$richtung === 'hoch' ? $index - 1 : $index + 1] ?? null;
}
/**
* Tauscht den Eintrag mit seinem Nachbarn derselben Ebene. Ohne gültigen Nachbarn geschieht nichts; die Ebene
* wechselt nie (WEB-12).
*/
public function verschiebe(string $k, string $richtung, bool $fokusZeile = false): void
{
$nachbar = $this->nachbar($k, $richtung);
if ($nachbar === null) {
return;
}
$a = array_search($k, $this->folge, true);
$b = array_search($nachbar, $this->folge, true);
[$this->folge[$a], $this->folge[$b]] = [$this->folge[$b], $this->folge[$a]];
$this->auswahl = $k;
if ($fokusZeile) {
$this->js("requestAnimationFrame(() => document.querySelector('[data-menue=\"$k\"] .vw-menue-waehlen')?.focus())");
}
}
/**
* Neue Reihenfolge einer Ebene nach Ziehen. Nur genau dieselben Geschwister werden umgeordnet.
*
* @param list<string> $schluessel
*/
public function sortiere(array $schluessel): void
{
$schluessel = array_values(array_filter($schluessel, fn ($k): bool => is_string($k) && isset($this->eintraege[$k])));
if ($schluessel === []) {
return;
}
$geschwister = $this->geschwister($schluessel[0]);
if (count($geschwister) !== count($schluessel) || array_diff($geschwister, $schluessel) !== []) {
return;
}
$positionen = array_map(fn (string $k): int => (int) array_search($k, $this->folge, true), $geschwister);
sort($positionen);
foreach ($positionen as $i => $position) {
$this->folge[$position] = $schluessel[$i];
}
}
public function eintragHinzufuegen(): void
{
$k = 'n'.(++$this->neu);
$this->eintraege[$k] = [
'id' => null,
'label' => '',
'page_id' => null,
'url' => '',
'placement' => $this->menue,
'parent' => null,
'is_visible' => true,
];
$this->folge[] = $k;
$this->auswahl = $k;
$this->js("requestAnimationFrame(() => document.getElementById('menue-text')?.focus())");
}
public function umschalten(string $k): void
{
if (isset($this->eintraege[$k])) {
$this->eintraege[$k]['is_visible'] = ! $this->eintraege[$k]['is_visible'];
$this->auswahl = $k;
}
}
/**
* Eingaben im Detailbereich: Folgen werden sofort im Arbeitsstand sichtbar.
*/
public function updatedEintraege(mixed $value, string $pfad): void
{
[$k, $feld] = array_pad(explode('.', $pfad, 2), 2, null);
if ($k === null || ! isset($this->eintraege[$k])) {
return;
}
$this->resetErrorBag("eintraege.$k.$feld");
match ($feld) {
'placement' => $this->bereichGeaendert($k),
'parent' => $this->elternGeaendert($k),
'page_id' => $this->eintraege[$k]['page_id'] = blank($value) ? null : (int) $value,
'is_visible' => $this->eintraege[$k]['is_visible'] = (bool) $value,
default => null,
};
}
private function bereichGeaendert(string $k): void
{
$bereich = $this->eintraege[$k]['placement'];
if (! array_key_exists($bereich, self::BEREICHE)) {
$this->eintraege[$k]['placement'] = 'header';
return;
}
// Untereinträge verschwänden öffentlich, wenn ihr Eintrag den Hauptmenü verließe (SiteNavigation::header()).
if ($bereich !== 'header' && $this->kinderVon($k) !== []) {
$this->eintraege[$k]['placement'] = 'header';
$this->addError("eintraege.$k.placement", 'Dieser Eintrag öffnet ein Untermenü. Ordnen Sie zuerst seine Untereinträge anders ein.');
return;
}
if ($bereich !== 'header') {
$this->eintraege[$k]['parent'] = null;
}
$this->ansEnde($k);
$this->menue = $bereich;
}
private function elternGeaendert(string $k): void
{
$eltern = blank($this->eintraege[$k]['parent']) ? null : (string) $this->eintraege[$k]['parent'];
$this->eintraege[$k]['parent'] = $eltern;
if ($eltern !== null && ! $this->kannEltern($k, $eltern)) {
$this->eintraege[$k]['parent'] = null;
$this->addError("eintraege.$k.parent", 'Untermenüs sind nur unter einem Eintrag der obersten Ebene der Hauptnavigation möglich.');
}
$this->ansEnde($k);
}
private function kannEltern(string $k, string $eltern): bool
{
return $eltern !== $k
&& isset($this->eintraege[$eltern])
&& $this->eintraege[$eltern]['placement'] === 'header'
&& $this->elternVon($eltern) === null
&& $this->kinderVon($k) === [];
}
/**
* Mögliche übergeordnete Einträge für den Eintrag: oberste Ebene des Hauptmenüs, nicht er selbst.
*
* @return array<string, string>
*/
public function elternOptionen(string $k): array
{
$optionen = [];
foreach ($this->baum('header') as $knoten) {
if ($knoten['k'] !== $k) {
$optionen[$knoten['k']] = trim($this->eintraege[$knoten['k']]['label']) ?: 'Ohne Menütext';
}
}
return $optionen;
}
/** Nach einem Ebenen- oder Bereichswechsel steht der Eintrag am Ende seiner neuen Ebene. */
private function ansEnde(string $k): void
{
$this->folge = [...array_values(array_filter($this->folge, fn (string $x): bool => $x !== $k)), $k];
}
public function zielAdresseNutzen(string $k): void
{
if (isset($this->eintraege[$k])) {
$this->eintraege[$k]['page_id'] = null;
$this->js("requestAnimationFrame(() => document.getElementById('menue-adresse')?.focus())");
}
}
public function oeffneZielwahl(string $k): void
{
if (isset($this->eintraege[$k])) {
$this->zielwahl = $k;
$this->zielSuche = '';
}
}
public function schliesseZielwahl(): void
{
$this->zielwahl = null;
}
public function waehleZiel(int $seiteId): void
{
if ($this->zielwahl === null || ! isset($this->eintraege[$this->zielwahl]) || ! CmsPage::query()->whereKey($seiteId)->exists()) {
return;
}
$this->eintraege[$this->zielwahl]['page_id'] = $seiteId;
$this->eintraege[$this->zielwahl]['url'] = '';
$this->resetErrorBag("eintraege.{$this->zielwahl}.url");
$this->zielwahl = null;
}
/**
* Seiten für „Ziel ändern“: Titel, Adresse und Veröffentlichungszustand.
*
* @return list<array{id: int, titel: string, pfad: string, zustand: array{label: string, ton: string}}>
*/
public function zielSeiten(): array
{
$needle = mb_strtolower(trim($this->zielSuche));
return CmsPage::query()->with('latestRevision')->orderBy('path')->get()
->map(fn (CmsPage $seite): array => [
'id' => $seite->id,
'titel' => $seite->latestRevision?->contentTitle() ?: $seite->path,
'pfad' => $seite->path,
'zustand' => $this->seitenZustand($seite),
])
->filter(fn (array $s): bool => $needle === '' || str_contains(mb_strtolower($s['titel'].' '.$s['pfad']), $needle))
->values()
->all();
}
/**
* @return array{label: string, ton: string}
*/
public function seitenZustand(CmsPage $seite): array
{
if ($seite->published_revision_id === null) {
return ['label' => 'Nur Entwurf, öffentlich nicht erreichbar', 'ton' => 'offen'];
}
return $seite->latestRevision !== null && $seite->latestRevision->id !== $seite->published_revision_id
? ['label' => 'Veröffentlicht · Entwurf neuer', 'ton' => 'gut']
: ['label' => 'Veröffentlicht', 'ton' => 'gut'];
}
/**
* Ziel eines Eintrags für Liste und Detailbereich.
*
* @return array{art: string, titel: ?string, pfad: ?string, zustand: ?array{label: string, ton: string}, seite: ?CmsPage}
*/
public function zielVon(string $k): array
{
$e = $this->eintraege[$k];
if ($e['page_id'] !== null) {
$seite = $this->seitenCache()->get((int) $e['page_id']);
return $seite === null
? ['art' => 'fehlt', 'titel' => null, 'pfad' => null, 'zustand' => ['label' => 'Zielseite nicht mehr vorhanden', 'ton' => 'achtung'], 'seite' => null]
: ['art' => 'seite', 'titel' => $seite->latestRevision?->contentTitle() ?: $seite->path, 'pfad' => $seite->path, 'zustand' => $this->seitenZustand($seite), 'seite' => $seite];
}
if (trim($e['url']) !== '') {
return ['art' => 'adresse', 'titel' => null, 'pfad' => trim($e['url']), 'zustand' => SafeUrl::isSafe(trim($e['url'])) ? null : ['label' => 'Adresse nicht zulässig', 'ton' => 'achtung'], 'seite' => null];
}
return ['art' => 'keins', 'titel' => null, 'pfad' => null, 'zustand' => null, 'seite' => null];
}
/** @var Collection<int, CmsPage>|null */
private ?Collection $seiten = null;
/**
* @return Collection<int, CmsPage>
*/
private function seitenCache(): Collection
{
return $this->seiten ??= CmsPage::query()->with('latestRevision')->get()->keyBy('id');
}
// ---------------------------------------------------------------------------------------------------------------
// Bestätigungen (gemeinsamer Dialog filament.verwaltung.bestaetigung)
// ---------------------------------------------------------------------------------------------------------------
public function askConfirmation(string $aktion, int|string|null $argument = null): void
{
if ($aktion === 'entfernen' && is_string($argument) && isset($this->eintraege[$argument])) {
$e = $this->eintraege[$argument];
$name = trim($e['label']) ?: 'Ohne Menütext';
$kinder = array_map(fn (string $k): string => '„'.(trim($this->eintraege[$k]['label']) ?: 'Ohne Menütext').'“', $this->kinderVon($argument));
$text = '„'.$name.'“ wird aus '.$this->bereichsName($e['placement']).' entfernt. Die Zielseite bleibt bestehen; ihre Veröffentlichung ändert sich nicht.';
if ($kinder !== []) {
$text .= ' '.(count($kinder) === 1 ? 'Der Untereintrag '.$kinder[0].' rückt' : 'Die Untereinträge '.implode(', ', $kinder).' rücken').' in die oberste Ebene des Hauptmenüs.';
}
$text .= ' Wirksam wird das erst mit „Menüänderungen speichern“.';
$this->bestaetigung = ['aktion' => 'entfernen', 'argument' => $argument, 'titel' => '„'.$name.'“ aus dem Menü entfernen?', 'text' => $text, 'label' => 'Aus Menü entfernen', 'gefahr' => true];
return;
}
$this->bestaetigung = match ($aktion) {
'verwerfen' => ['aktion' => 'verwerfen', 'argument' => null, 'titel' => 'Menüänderungen verwerfen?', 'text' => 'Alle Menüs kehren zum gespeicherten Stand zurück. Betroffen: '.implode(', ', array_map($this->bereichsName(...), $this->betroffeneBereiche())).'.', 'label' => 'Verwerfen', 'gefahr' => true],
'neuLaden' => ['aktion' => 'neuLaden', 'argument' => null, 'titel' => 'Gespeicherten Stand laden?', 'text' => 'Die Menüs wurden inzwischen an anderer Stelle gespeichert. Laden zeigt diesen Stand; Ihre ungespeicherten Menüänderungen gehen dabei verloren.', 'label' => 'Gespeicherten Stand laden', 'gefahr' => true],
default => null,
};
}
public function confirmConfirmation(): void
{
$frage = $this->bestaetigung;
$this->bestaetigung = null;
match ($frage['aktion'] ?? null) {
'entfernen' => $this->entferne((string) $frage['argument']),
'verwerfen', 'neuLaden' => $this->neuLaden(),
default => null,
};
}
public function cancelConfirmation(): void
{
$this->bestaetigung = null;
}
private function neuLaden(): void
{
$auswahl = $this->auswahl;
$this->ladeMenues();
$this->auswahl = $auswahl !== null && isset($this->eintraege[$auswahl]) ? $auswahl : $this->ersterEintrag($this->menue);
}
/**
* Entfernt den Eintrag aus dem Arbeitsstand. Untereinträge rücken in die oberste Ebene, wie es die Datenbank beim
* Löschen tut (parent_id nullOnDelete).
*/
private function entferne(string $k): void
{
if (! isset($this->eintraege[$k])) {
return;
}
$geschwister = $this->geschwister($k);
$index = (int) array_search($k, $geschwister, true);
foreach ($this->kinderVon($k) as $kind) {
$this->eintraege[$kind]['parent'] = null;
}
if ($this->eintraege[$k]['id'] !== null) {
$this->entfernt[] = (int) $this->eintraege[$k]['id'];
}
unset($this->eintraege[$k]);
$this->folge = array_values(array_filter($this->folge, fn (string $x): bool => $x !== $k));
$rest = array_values(array_filter($geschwister, fn (string $x): bool => $x !== $k));
$this->auswahl = $rest[min($index, count($rest) - 1)] ?? $this->ersterEintrag($this->menue);
}
// ---------------------------------------------------------------------------------------------------------------
// Speichern
// ---------------------------------------------------------------------------------------------------------------
public function speichern(): void
{
$bereiche = $this->betroffeneBereiche();
if ($bereiche === []) {
Notification::make()->title('Keine Menüänderungen zu speichern')->send();
return;
}
$geaendert = $this->pruefen();
try {
$ids = DB::transaction(fn (): array => $this->schreiben($geaendert));
} catch (RuntimeException $exception) {
if ($exception->getMessage() !== 'veraltet') {
throw $exception;
}
$this->konflikt = true;
Notification::make()->title('Nicht gespeichert: Die Menüs wurden inzwischen an anderer Stelle geändert')
->body('Ihre Änderungen sind noch offen. „Gespeicherten Stand laden“ zeigt den neuen Stand.')
->danger()->persistent()->send();
return;
}
$auswahl = $this->auswahl;
$this->ladeMenues();
$this->auswahl = $auswahl !== null && isset($ids[$auswahl]) ? 'e'.$ids[$auswahl] : $this->ersterEintrag($this->menue);
Notification::make()
->title('Menüänderungen gespeichert')
->body('Die öffentliche Navigation zeigt jetzt den neuen Stand: '.implode(', ', array_map($this->bereichsName(...), $bereiche)).'.')
->success()
->send();
}
/**
* Regeln der bisherigen Navigationsverwaltung für jeden neuen oder geänderten Eintrag sowie für Einträge, deren
* Untereinträge sich geändert haben. Beim ersten Fehler wird der Eintrag ausgewählt und sein Bereich gezeigt.
*
* @return list<string> Schlüssel der neuen oder geänderten Einträge
*/
private function pruefen(): array
{
$gespeichert = NavigationItem::query()->get()->keyBy('id');
$kinderVorher = $gespeichert->groupBy('parent_id')->map(fn (Collection $c): array => $c->pluck('id')->sort()->values()->all());
$fehler = [];
$erster = null;
$alleGeaendert = [];
foreach ($this->folge as $k) {
$e = $this->eintraege[$k];
$alt = $e['id'] !== null ? $gespeichert->get($e['id']) : null;
$kinder = $this->kinderVon($k);
$kinderIds = collect($kinder)->map(fn (string $x): ?int => $this->eintraege[$x]['id'])->filter()->sort()->values()->all();
$geaendert = $alt === null
|| $alt->label !== $e['label']
|| $alt->page_id !== ($e['page_id'] !== null ? (int) $e['page_id'] : null)
|| (string) ($alt->url ?? '') !== $e['url']
|| $alt->placement !== $e['placement']
|| ($alt->parent_id !== null ? 'e'.$alt->parent_id : null) !== $this->elternVon($k)
|| (bool) $alt->is_visible !== (bool) $e['is_visible']
|| count($kinder) !== count($kinderIds)
|| ($kinderVorher->get($e['id']) ?? []) !== $kinderIds;
if (! $geaendert) {
continue;
}
$alleGeaendert[] = $k;
$eltern = $this->elternVon($k);
$validator = Validator::make([
'label' => trim($e['label']),
'placement' => $e['placement'],
'page_id' => $e['page_id'],
'url' => trim($e['url']) === '' ? null : trim($e['url']),
], [
'label' => ['required', 'string', 'max:80'],
'placement' => ['required', 'in:'.implode(',', array_keys(self::BEREICHE))],
'page_id' => ['nullable', 'integer', 'exists:pages,id'],
'url' => ['nullable', 'string', 'max:500', SafeUrl::rule()],
], [
'label.required' => 'Bitte einen Menütext eingeben.',
'label.max' => 'Der Menütext hat höchstens 80 Zeichen.',
'url.max' => 'Die Adresse hat höchstens 500 Zeichen.',
'page_id.exists' => 'Diese Seite gibt es nicht mehr.',
]);
$meldungen = $validator->errors()->toArray();
if ($eltern !== null && ! $this->kannEltern($k, $eltern)) {
$meldungen['parent'][] = 'Untermenüs sind nur unter einem Eintrag der obersten Ebene der Hauptnavigation möglich.';
}
if ($e['placement'] !== 'header' && $kinder !== []) {
$meldungen['placement'][] = 'Dieser Eintrag öffnet ein Untermenü. Ordnen Sie zuerst seine Untereinträge anders ein.';
}
// Ein Eintrag mit Untereinträgen darf ohne eigenes Ziel nur das Untermenü öffnen.
if ($e['page_id'] === null && trim($e['url']) === '' && $kinder === []) {
$meldungen['url'][] = 'Wählen Sie eine Seite oder eine Adresse.';
}
foreach ($meldungen as $feld => $texte) {
$fehler["eintraege.$k.$feld"] = array_values(array_unique($texte));
}
if ($meldungen !== [] && $erster === null) {
$erster = $k;
}
}
if ($erster !== null) {
$this->register = 'menues';
$this->waehle($erster);
throw ValidationException::withMessages($fehler);
}
return $alleGeaendert;
}
/**
* Schreibt den Arbeitsstand. Geänderte Einträge werden vollständig geschrieben, unveränderte höchstens mit neuer
* Reihenfolge. sort_order bleibt erhalten, wo die Folge es zulässt (verglichen wie die Datenbank ordnet: Reihenfolge,
* dann Kennung); sonst rückt der Eintrag unmittelbar hinter seinen Vorgänger.
*
* @param list<string> $geaendert
* @return array<string, int> Schlüssel => gespeicherte Kennung
*/
private function schreiben(array $geaendert): array
{
$aktuell = NavigationItem::query()->lockForUpdate()->get()->keyBy('id');
$standJetzt = $aktuell->mapWithKeys(fn (NavigationItem $item): array => ['e'.$item->id => (string) $item->getRawOriginal('updated_at')])->all();
ksort($standJetzt);
$standGeladen = $this->stand;
ksort($standGeladen);
if ($standJetzt !== $standGeladen) {
throw new RuntimeException('veraltet');
}
$user = auth()->user();
$reihe = [
...array_values(array_filter($this->folge, fn (string $k): bool => $this->elternVon($k) === null)),
...array_values(array_filter($this->folge, fn (string $k): bool => $this->elternVon($k) !== null)),
];
// Öffentlich zählt die Folge nur innerhalb eines Bereichs (SiteNavigation filtert nach Bereich). Deshalb wird je
// Bereich nummeriert: Eine Umordnung im Hauptmenü schreibt keinen Eintrag des Fußbereichs.
$sortierung = [];
$letzte = [];
foreach ($this->folge as $k) {
$bereich = $this->eintraege[$k]['placement'];
$id = $this->eintraege[$k]['id'];
$bisher = $id !== null ? $aktuell->get($id)?->sort_order : null;
[$vorher, $vorherId] = $letzte[$bereich] ?? [-1, -1];
// Neue Einträge erhalten die größte Kennung; sie stehen bei gleicher Reihenfolge also hinten.
$vergleichsId = $id ?? PHP_INT_MAX;
$wert = $bisher !== null && ([(int) $bisher, $vergleichsId] <=> [$vorher, $vorherId]) > 0 ? (int) $bisher : $vorher + 1;
$letzte[$bereich] = [$wert, $vergleichsId];
$sortierung[$k] = $wert;
}
$ids = [];
foreach ($reihe as $k) {
$e = $this->eintraege[$k];
$item = $e['id'] !== null ? $aktuell->get($e['id']) : new NavigationItem;
abort_if($item === null, 409);
abort_unless($user?->can($item->exists ? 'update' : 'create', $item->exists ? $item : NavigationItem::class), 403);
if ($item->exists && ! in_array($k, $geaendert, true)) {
if ((int) $item->sort_order !== $sortierung[$k]) {
$item->sort_order = $sortierung[$k];
$item->save();
}
$ids[$k] = $item->id;
continue;
}
$eltern = $this->elternVon($k);
$item->fill([
'label' => trim($e['label']),
'page_id' => $e['page_id'] !== null ? (int) $e['page_id'] : null,
'url' => trim($e['url']) === '' ? null : trim($e['url']),
'placement' => $e['placement'],
'parent_id' => $eltern !== null ? ($ids[$eltern] ?? $this->eintraege[$eltern]['id']) : null,
'is_visible' => (bool) $e['is_visible'],
'sort_order' => $sortierung[$k],
]);
if ($item->isDirty()) {
$item->save();
}
$ids[$k] = $item->id;
}
foreach ($this->entfernt as $id) {
$item = $aktuell->get($id);
if ($item !== null) {
abort_unless($user?->can('delete', $item), 403);
$item->delete();
}
}
return $ids;
}
}