Kompakter Kopf mit aufrufbarer Hilfe statt wiederholter Erläuterungen zu Sortierung, Ausblenden, Speichern und Veröffentlichung. Seitenliste: Chip „Veröffentlicht“, Revisionsnummer in der Detailzeile; Listenhinweis nur noch bei offenen Menüänderungen. Menüs: kein Dauerband und keine Wiederholungen mehr im Detailbereich. Funktionen und Zustände unverändert. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1070 lines
41 KiB
PHP
1070 lines
41 KiB
PHP
<?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' => $this->menuesGeaendert() ? 'Im Register „Menüs“ gibt es ungespeicherte Änderungen. Die Menüzuordnungen hier zeigen den gespeicherten Stand.' : null,
|
||
'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', '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')
|
||
.($seite->published_revision_id !== null ? ' · öffentlich: Revision '.$seite->published_revision_id : '')];
|
||
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;
|
||
}
|
||
}
|