CI Feature / test (push) Successful in 56s
Medium, Modul, Programm und Lizenzartikel nutzen denselben Objektkopf, dieselben Register (Texte, Präsentationsmedien, Einordnung) und denselben visuellen Picker. Präsentationsmedien, Abweichungen und Texte bilden einen Arbeitsstand, den nur „Redaktion speichern“ schreibt; Austausch behält die Position, Sortierung bleibt in der Rolle. Der Wechsel zur Redaktion und zurück erhält offene Eingaben des Ausgangseditors. Entfernt versteckte Mitspeicherungen: Der Didaktikdialog schreibt keine Redaktionstexte mehr, die Website-Freigabe keine offenen Quellenzeilen, Entwurf verwerfen setzt keine offenen Redaktionseingaben zurück. Tests, die alte Orte oder CSS-Zeichenketten prüften, sind auf die neue Bedienung umgestellt; neue Tests decken Arbeitsstand, Austausch, Abbrechen und Rückweg ab. Datenmodell, Fassungen und Rechte bleiben unverändert. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1148 lines
35 KiB
PHP
1148 lines
35 KiB
PHP
<?php
|
|
|
|
namespace App\Filament\Support;
|
|
|
|
use App\Domain\Catalog\ContentElement;
|
|
use App\Domain\Catalog\ContentElementVersion;
|
|
use App\Domain\Catalog\ContentVersionStatus;
|
|
use App\Domain\Catalog\DomainRuleException;
|
|
use App\Domain\Catalog\EditorialProfile;
|
|
use App\Domain\Catalog\EditorialProfileReader;
|
|
use App\Domain\Catalog\EditorialTextVariant;
|
|
use App\Domain\Catalog\PresentationMedia;
|
|
use App\Domain\Catalog\PresentationRole;
|
|
use App\Domain\Cms\Catalog\PublicMaterialReader;
|
|
use App\Domain\Media\WebsiteRelease;
|
|
use App\Filament\Resources\ContentElements\ContentElementResource;
|
|
use App\Http\Controllers\ContentPreviewController;
|
|
use App\Models\User;
|
|
use Illuminate\Database\Eloquent\Model;
|
|
|
|
/**
|
|
* Gemeinsamer Redaktionsmanager für Medien, Module, Programme und Lizenzartikel.
|
|
*
|
|
* Der Manager läuft in derselben Livewire-Komponente wie der Ausgangseditor. Dessen offene Eingaben bleiben dadurch
|
|
* beim Wechsel erhalten. Texte, Einordnung, Präsentationsmedien und abweichende Formulierungen sind ein Arbeitsstand,
|
|
* den nur „Redaktion speichern“ schreibt. Website-Freigaben eines Mediums wirken dagegen sofort und global.
|
|
*
|
|
* Die Seite liefert die objektspezifischen Teile: redaktionKopf(), redaktionFelder(), einordnungGruppen(),
|
|
* einordnungUnsaved(), saveRedaktionTexte() und resetRedaktionTexte().
|
|
*/
|
|
trait ManagesEditorialSurface
|
|
{
|
|
public bool $redaktionOpen = false;
|
|
|
|
public string $redaktionTab = 'texte';
|
|
|
|
public string $deskFeedback = '';
|
|
|
|
public bool $deskFeedbackError = false;
|
|
|
|
public string $redaktionFehlerFeld = '';
|
|
|
|
/** @var list<array{key: string, id: int|null, role: string, element_id: int, source: int|null}> */
|
|
public array $praesentation = [];
|
|
|
|
/** @var list<array{key: string, id: int|null, role: string, element_id: int, source: int|null}>|null */
|
|
public ?array $praesentationGespeichert = null;
|
|
|
|
public ?string $praesentationFokus = null;
|
|
|
|
/** @var list<array{field: string, audience: string, body: string}> */
|
|
public array $varianten = [];
|
|
|
|
/** @var list<array{field: string, audience: string, body: string}>|null */
|
|
public ?array $variantenGespeichert = null;
|
|
|
|
public string $variantAudience = 'kachel';
|
|
|
|
public string $variantField = 'teaser';
|
|
|
|
public string $variantBody = '';
|
|
|
|
public bool $ausgabeOpen = false;
|
|
|
|
public bool $pickerOpen = false;
|
|
|
|
public string $pickerPurpose = 'praesentation';
|
|
|
|
public string $pickerQuery = '';
|
|
|
|
public string $pickerKind = 'alle';
|
|
|
|
public string $pickerDimension = '';
|
|
|
|
public string $pickerInspected = '';
|
|
|
|
public string $pickerSelected = '';
|
|
|
|
/** @var array<string, string> Ziel => Titel; bleibt bei Suche und Filter erhalten */
|
|
public array $pickerMarked = [];
|
|
|
|
public string $presentationRole = 'titelbild';
|
|
|
|
public bool $bindToVersion = false;
|
|
|
|
public ?string $replacingKey = null;
|
|
|
|
public function getBreadcrumbs(): array
|
|
{
|
|
return [];
|
|
}
|
|
|
|
public function getHeading(): string
|
|
{
|
|
return '';
|
|
}
|
|
|
|
public function getSubheading(): ?string
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public function editorialSubject(): Model
|
|
{
|
|
return $this->getRecord();
|
|
}
|
|
|
|
public function editorialProfile(?string $audience = null): EditorialProfile
|
|
{
|
|
return app(EditorialProfileReader::class)->read($this->editorialSubject(), $audience);
|
|
}
|
|
|
|
public function canEditEditorial(): bool
|
|
{
|
|
return ContentElementResource::editor();
|
|
}
|
|
|
|
public function canReleasePresentation(): bool
|
|
{
|
|
return ContentElementResource::editor();
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Wechsel, Status und Speichern
|
|
|
|
public function openRedaktion(string $tab = 'texte'): void
|
|
{
|
|
abort_unless($this->canViewEditorial(), 403);
|
|
$this->redaktionWillOpen();
|
|
$this->loadRedaktionStaging();
|
|
$this->redaktionOpen = true;
|
|
$this->redaktionTab = in_array($tab, ['texte', 'medien', 'einordnung'], true) ? $tab : 'texte';
|
|
$this->ausgabeOpen = false;
|
|
$this->deskFeedback = '';
|
|
}
|
|
|
|
/**
|
|
* Für Seiten, die beim Wechsel eigene Dialoge schließen. Offene Eingaben bleiben dabei erhalten.
|
|
*/
|
|
protected function redaktionWillOpen(): void {}
|
|
|
|
public function closeRedaktion(): void
|
|
{
|
|
$this->redaktionOpen = false;
|
|
$this->ausgabeOpen = false;
|
|
$this->closePicker();
|
|
$this->deskFeedback = '';
|
|
}
|
|
|
|
public function showRedaktionTab(string $tab): void
|
|
{
|
|
if (in_array($tab, ['texte', 'medien', 'einordnung'], true)) {
|
|
$this->redaktionTab = $tab;
|
|
}
|
|
}
|
|
|
|
public function canViewEditorial(): bool
|
|
{
|
|
return $this->canEditEditorial() || ContentElementResource::editor();
|
|
}
|
|
|
|
public function saveRedaktion(): void
|
|
{
|
|
$this->guardEditorial();
|
|
$this->loadRedaktionStaging();
|
|
$this->deskFeedbackError = false;
|
|
$this->redaktionFehlerFeld = '';
|
|
|
|
if (! $this->saveRedaktionTexte()) {
|
|
$this->deskFeedbackError = true;
|
|
$this->redaktionTab = 'texte';
|
|
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if ($this->presentationUnsaved()) {
|
|
app(PresentationMedia::class)->commit($this->editorialSubject(), $this->praesentation, $this->deskActor());
|
|
}
|
|
|
|
if ($this->variantsUnsaved()) {
|
|
$this->commitVariants();
|
|
}
|
|
} catch (DomainRuleException $exception) {
|
|
$this->deskFeedback = 'Die Texte sind gespeichert. '.$exception->getMessage();
|
|
$this->deskFeedbackError = true;
|
|
|
|
return;
|
|
}
|
|
|
|
$this->praesentationGespeichert = null;
|
|
$this->variantenGespeichert = null;
|
|
$this->praesentationFokus = null;
|
|
$this->loadRedaktionStaging();
|
|
$this->deskFeedback = $this->redaktionSavedMessage();
|
|
}
|
|
|
|
public function discardRedaktion(): void
|
|
{
|
|
$this->resetRedaktionTexte();
|
|
$this->praesentationGespeichert = null;
|
|
$this->variantenGespeichert = null;
|
|
$this->praesentationFokus = null;
|
|
$this->loadRedaktionStaging();
|
|
$this->closePicker();
|
|
$this->deskFeedbackError = false;
|
|
$this->deskFeedback = 'Die ungespeicherten Änderungen der Redaktion sind verworfen. Die übrige Bearbeitung bleibt unverändert.';
|
|
}
|
|
|
|
public function redaktionOffen(): bool
|
|
{
|
|
return $this->redaktionUnsaved() || $this->presentationUnsaved() || $this->variantsUnsaved();
|
|
}
|
|
|
|
/**
|
|
* Welche Register ungespeicherte Änderungen enthalten.
|
|
*
|
|
* @return array{texte: bool, medien: bool, einordnung: bool}
|
|
*/
|
|
public function redaktionOffeneRegister(): array
|
|
{
|
|
$texte = $this->variantsUnsaved();
|
|
|
|
foreach ($this->redaktionFelder() as $feld) {
|
|
if ($this->feldGeaendert($feld)) {
|
|
$texte = true;
|
|
}
|
|
}
|
|
|
|
return [
|
|
'texte' => $texte,
|
|
'medien' => $this->presentationUnsaved(),
|
|
'einordnung' => $this->einordnungUnsaved(),
|
|
];
|
|
}
|
|
|
|
public function redaktionUnsaved(): bool
|
|
{
|
|
return $this->textFieldsChanged() || $this->einordnungUnsaved();
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $feld
|
|
*/
|
|
public function feldGeaendert(array $feld): bool
|
|
{
|
|
$model = (string) $feld['model'];
|
|
|
|
return trim((string) $this->{$model}) !== trim((string) ($feld['stored'] ?? ''));
|
|
}
|
|
|
|
public function textFieldsChanged(): bool
|
|
{
|
|
foreach ($this->redaktionFelder() as $feld) {
|
|
if ($this->feldGeaendert($feld)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function redaktionSavedMessage(): string
|
|
{
|
|
return 'Die Redaktion ist gespeichert. Es entsteht keine neue Fassung.';
|
|
}
|
|
|
|
protected function loadRedaktionStaging(): void
|
|
{
|
|
if ($this->praesentationGespeichert === null) {
|
|
$this->praesentation = app(PresentationMedia::class)->staged($this->editorialSubject());
|
|
$this->praesentationGespeichert = $this->praesentation;
|
|
}
|
|
|
|
if ($this->variantenGespeichert === null) {
|
|
$this->varianten = $this->storedVariants();
|
|
$this->variantenGespeichert = $this->varianten;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Ausgabe prüfen
|
|
|
|
public function openAusgabe(): void
|
|
{
|
|
$this->ausgabeOpen = $this->redaktionAusgabe() !== null;
|
|
}
|
|
|
|
public function closeAusgabe(): void
|
|
{
|
|
$this->ausgabeOpen = false;
|
|
}
|
|
|
|
/**
|
|
* Ausgabe des Objekts für „Ausgabe prüfen“. Null, wenn es für diese Objektart keine Ausgabe gibt.
|
|
*
|
|
* @return array{html?: string, view?: string, stand: string}|null
|
|
*/
|
|
public function redaktionAusgabe(): ?array
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Präsentationsmedien (Arbeitsstand)
|
|
|
|
public function presentationUnsaved(): bool
|
|
{
|
|
if ($this->praesentationGespeichert === null) {
|
|
return false;
|
|
}
|
|
|
|
return $this->stagingFingerprint($this->praesentation) !== $this->stagingFingerprint($this->praesentationGespeichert);
|
|
}
|
|
|
|
/**
|
|
* @return list<array{role: string, label: string, multiple: bool, ordered: bool, rows: list<array<string, mixed>>}>
|
|
*/
|
|
public function presentationGroups(): array
|
|
{
|
|
$this->loadRedaktionStaging();
|
|
|
|
return app(PresentationMedia::class)->describe($this->praesentation);
|
|
}
|
|
|
|
/**
|
|
* @return array<string, string>
|
|
*/
|
|
public function presentationRoleOptions(): array
|
|
{
|
|
$options = [];
|
|
|
|
foreach (PresentationRole::selectOptions() as $slug => $label) {
|
|
$options[$slug] = PresentationRole::displayLabel((string) $slug, (string) $label);
|
|
}
|
|
|
|
return $options;
|
|
}
|
|
|
|
public function removePresentation(string $key): void
|
|
{
|
|
$this->guardEditorial();
|
|
$before = count($this->praesentation);
|
|
$this->praesentation = array_values(array_filter($this->praesentation, fn (array $row): bool => $row['key'] !== $key));
|
|
|
|
if (count($this->praesentation) === $before) {
|
|
$this->feedback('Diese Zuordnung gibt es nicht mehr.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->praesentationFokus = null;
|
|
$this->feedback('Die Zuordnung ist entfernt. Das Medium bleibt im Bestand. Wirksam wird das mit „Redaktion speichern“.');
|
|
}
|
|
|
|
public function movePresentation(string $key, int $direction): void
|
|
{
|
|
$this->guardEditorial();
|
|
$index = $this->stagingIndex($key);
|
|
|
|
if ($index === null || $direction === 0) {
|
|
return;
|
|
}
|
|
|
|
$role = $this->praesentation[$index]['role'];
|
|
|
|
if (! $this->roleIsOrdered($role)) {
|
|
$this->feedback('Diese Rolle hat eine einzelne Zuordnung und wird nicht sortiert.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$siblings = $this->stagingIndexesOfRole($role);
|
|
$position = array_search($index, $siblings, true);
|
|
$target = $position + ($direction < 0 ? -1 : 1);
|
|
|
|
if ($position === false || ! isset($siblings[$target])) {
|
|
return;
|
|
}
|
|
|
|
$other = $siblings[$target];
|
|
[$this->praesentation[$index], $this->praesentation[$other]] = [$this->praesentation[$other], $this->praesentation[$index]];
|
|
$this->praesentationFokus = $key;
|
|
$this->deskFeedback = '';
|
|
}
|
|
|
|
public function placePresentation(string $key, string $beforeKey): void
|
|
{
|
|
$this->guardEditorial();
|
|
$from = $this->stagingIndex($key);
|
|
$to = $this->stagingIndex($beforeKey);
|
|
|
|
if ($from === null || $to === null || $from === $to) {
|
|
return;
|
|
}
|
|
|
|
$role = $this->praesentation[$from]['role'];
|
|
|
|
if ($this->praesentation[$to]['role'] !== $role || ! $this->roleIsOrdered($role)) {
|
|
$this->feedback('Die Reihenfolge gilt nur innerhalb einer Rolle.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$siblings = $this->stagingIndexesOfRole($role);
|
|
$fromPosition = array_search($from, $siblings, true);
|
|
$toPosition = array_search($to, $siblings, true);
|
|
$direction = $toPosition < $fromPosition ? -1 : 1;
|
|
|
|
for ($step = 0; $step < abs($toPosition - $fromPosition); $step++) {
|
|
$this->movePresentation($key, $direction);
|
|
}
|
|
}
|
|
|
|
public function releaseAssigned(int $elementId): void
|
|
{
|
|
abort_unless($this->canReleasePresentation(), 403);
|
|
$element = ContentElement::query()->find($elementId);
|
|
|
|
if (! $element instanceof ContentElement) {
|
|
$this->feedback('Das Medium fehlt.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->feedback(app(WebsiteRelease::class)->release($element, $this->deskActor()));
|
|
}
|
|
|
|
public function withdrawAssigned(int $elementId): void
|
|
{
|
|
abort_unless($this->canReleasePresentation(), 403);
|
|
$element = ContentElement::query()->find($elementId);
|
|
|
|
if (! $element instanceof ContentElement) {
|
|
$this->feedback('Das Medium fehlt.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->feedback(app(WebsiteRelease::class)->withdraw($element, $this->deskActor()));
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Gemeinsamer Picker
|
|
|
|
public function openPresentationPicker(?string $role = null): void
|
|
{
|
|
$this->guardEditorial();
|
|
$this->loadRedaktionStaging();
|
|
$roles = $this->presentationRoleOptions();
|
|
$this->presentationRole = $role !== null && isset($roles[$role]) ? $role : (isset($roles[$this->presentationRole]) ? $this->presentationRole : (string) array_key_first($roles));
|
|
$this->resetPicker('praesentation');
|
|
$this->pickerKind = $this->defaultKindForRole($this->presentationRole);
|
|
}
|
|
|
|
public function beginExchange(string $key): void
|
|
{
|
|
$this->guardEditorial();
|
|
$index = $this->stagingIndex($key);
|
|
|
|
if ($index === null) {
|
|
$this->feedback('Diese Zuordnung gibt es nicht mehr.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->presentationRole = $this->praesentation[$index]['role'];
|
|
$this->resetPicker('austausch');
|
|
$this->replacingKey = $key;
|
|
$this->pickerKind = $this->defaultKindForRole($this->presentationRole);
|
|
}
|
|
|
|
public function updatedPresentationRole(string $value): void
|
|
{
|
|
if ($this->pickerPurpose === 'praesentation') {
|
|
$this->pickerKind = $this->defaultKindForRole($value);
|
|
}
|
|
|
|
if (! in_array($value, PresentationRole::BOUND_ROLES, true)) {
|
|
$this->bindToVersion = false;
|
|
}
|
|
|
|
if (! $this->pickerAllowsMany() && count($this->pickerMarked) > 1) {
|
|
$first = array_key_first($this->pickerMarked);
|
|
$this->pickerMarked = [$first => $this->pickerMarked[$first]];
|
|
}
|
|
}
|
|
|
|
public function closePicker(): void
|
|
{
|
|
$wasExchange = $this->pickerPurpose === 'austausch' && $this->pickerOpen;
|
|
$this->pickerOpen = false;
|
|
$this->pickerSelected = '';
|
|
$this->pickerInspected = '';
|
|
$this->pickerMarked = [];
|
|
$this->replacingKey = null;
|
|
|
|
if ($wasExchange) {
|
|
$this->feedback('Die vorhandene Zuordnung bleibt unverändert.');
|
|
}
|
|
}
|
|
|
|
public function inspectPicker(string $target, bool $mark = false): void
|
|
{
|
|
$this->pickerInspected = $target;
|
|
|
|
if ($mark) {
|
|
$this->markPicker($target, true);
|
|
}
|
|
}
|
|
|
|
public function togglePick(string $target): void
|
|
{
|
|
$this->markPicker($target, ! isset($this->pickerMarked[$target]));
|
|
}
|
|
|
|
public function markPicker(string $target, bool $on): void
|
|
{
|
|
if (! $on) {
|
|
unset($this->pickerMarked[$target]);
|
|
|
|
if ($this->pickerSelected === $target) {
|
|
$this->pickerSelected = '';
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
$row = app(EditorialCatalog::class)->rowForTarget($target, $this->pickerExceptId(), allowDraft: true);
|
|
|
|
if ($row === null) {
|
|
return;
|
|
}
|
|
|
|
if (! $this->pickerAllowsMany()) {
|
|
$this->pickerMarked = [];
|
|
$this->pickerSelected = $target;
|
|
}
|
|
|
|
$this->pickerMarked[$target] = (string) $row['title'];
|
|
|
|
if ($this->pickerInspected === '') {
|
|
$this->pickerInspected = $target;
|
|
}
|
|
}
|
|
|
|
public function pickerAllowsMany(): bool
|
|
{
|
|
return $this->pickerPurpose === 'praesentation' && $this->roleAllowsMany($this->presentationRole);
|
|
}
|
|
|
|
public function confirmPicker(): void
|
|
{
|
|
$marked = array_keys($this->pickerMarked);
|
|
|
|
if ($marked === []) {
|
|
return;
|
|
}
|
|
|
|
if ($this->pickerPurpose === 'aufbau') {
|
|
$target = $marked[0];
|
|
$this->closePicker();
|
|
|
|
if (method_exists($this, 'addPart')) {
|
|
$this->addPart($target);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
$this->guardEditorial();
|
|
|
|
if ($this->pickerPurpose === 'austausch') {
|
|
$this->exchangeStaged($marked[0]);
|
|
|
|
return;
|
|
}
|
|
|
|
$added = [];
|
|
$notes = [];
|
|
|
|
foreach ($marked as $target) {
|
|
$result = $this->stageTarget($target);
|
|
|
|
if ($result === true) {
|
|
$added[] = $this->pickerMarked[$target];
|
|
} else {
|
|
$notes[] = $result;
|
|
}
|
|
}
|
|
|
|
$this->pickerOpen = false;
|
|
$this->pickerMarked = [];
|
|
$this->pickerSelected = '';
|
|
$this->pickerInspected = '';
|
|
$this->redaktionTab = 'medien';
|
|
$label = $this->presentationRoleOptions()[$this->presentationRole] ?? 'Rolle';
|
|
$message = $added === []
|
|
? ''
|
|
: (count($added) === 1 ? '„'.$added[0].'“ ist' : count($added).' Medien sind').' als '.$label.' vorgemerkt. Wirksam wird das mit „Redaktion speichern“.';
|
|
$this->feedback(trim($message.' '.implode(' ', $notes)), $added === []);
|
|
}
|
|
|
|
/**
|
|
* Einzelnes Ziel direkt übernehmen (Tastatur- und Testpfad für den Picker).
|
|
*/
|
|
public function assignFromPicker(string $target): void
|
|
{
|
|
if (! $this->pickerOpen) {
|
|
$this->openPresentationPicker($this->presentationRole);
|
|
}
|
|
|
|
$this->pickerMarked = [];
|
|
$this->markPicker($target, true);
|
|
$this->confirmPicker();
|
|
}
|
|
|
|
/**
|
|
* @return array{items: list<array<string, mixed>>, more: bool}
|
|
*/
|
|
public function pickerResult(): array
|
|
{
|
|
if (! $this->pickerOpen) {
|
|
return ['items' => [], 'more' => false];
|
|
}
|
|
|
|
if ($this->pickerPurpose === 'aufbau') {
|
|
return app(EditorialCatalog::class)->browse(
|
|
$this->pickerQuery,
|
|
$this->pickerKind,
|
|
$this->pickerDimension,
|
|
$this->pickerExceptId(),
|
|
);
|
|
}
|
|
|
|
return app(EditorialCatalog::class)->presentationBrowse($this->pickerQuery, $this->pickerKind);
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>|null
|
|
*/
|
|
public function pickerDetail(): ?array
|
|
{
|
|
$target = $this->pickerInspected !== '' ? $this->pickerInspected : $this->pickerSelected;
|
|
|
|
if ($target === '') {
|
|
return null;
|
|
}
|
|
|
|
$row = app(EditorialCatalog::class)->rowForTarget($target, $this->pickerExceptId(), allowDraft: true);
|
|
|
|
if ($row === null) {
|
|
return null;
|
|
}
|
|
|
|
$row['playback'] = null;
|
|
$row['file_url'] = null;
|
|
$elementId = isset($row['element_id']) ? (int) $row['element_id'] : 0;
|
|
|
|
if (preg_match('/^element:(\d+)$/', (string) $row['target'], $match) === 1) {
|
|
$version = ContentElementVersion::query()->with('element.editorialContentKind')->find($match[1]);
|
|
|
|
if ($version instanceof ContentElementVersion) {
|
|
$row['playback'] = app(ContentPreviewController::class)->playback($version);
|
|
}
|
|
}
|
|
|
|
$element = $elementId > 0 ? ContentElement::query()->with(['editorialContentKind', 'pillars'])->find($elementId) : null;
|
|
|
|
if ($element instanceof ContentElement) {
|
|
$row['visibility'] = app(PublicMaterialReader::class)->visibilityNote($element);
|
|
$row['released'] = $element->website_released_at !== null;
|
|
$row['output_label'] = PublicMaterialReader::outputLabel((string) $element->output_class);
|
|
$row['pillars'] = $element->pillars->pluck('name')->all();
|
|
$row['usage'] = app(CatalogReading::class)->elementUsage($element);
|
|
}
|
|
|
|
return $row;
|
|
}
|
|
|
|
/**
|
|
* @return list<array{target: string, label: string, current: bool}>
|
|
*/
|
|
public function pickerVersions(): array
|
|
{
|
|
$detail = $this->pickerDetail();
|
|
|
|
if ($detail === null) {
|
|
return [];
|
|
}
|
|
|
|
$options = app(EditorialCatalog::class)->alternatives((string) ($detail['identity'] ?? ''), $this->pickerExceptId());
|
|
|
|
if ($options === []) {
|
|
return [];
|
|
}
|
|
|
|
$current = $options[array_key_last($options)]['target'];
|
|
|
|
return array_map(fn (array $option): array => $option + ['current' => $option['target'] === $current], $options);
|
|
}
|
|
|
|
/**
|
|
* @return array<string, string>
|
|
*/
|
|
public function pickerKinds(): array
|
|
{
|
|
if ($this->pickerPurpose === 'aufbau') {
|
|
return ['alle' => 'Alle Inhalte', 'film' => 'Filme', 'bild' => 'Bilder', 'audio' => 'Hörstücke', 'dokument' => 'Dokumente', 'text' => 'Texte', 'modul' => 'Module'];
|
|
}
|
|
|
|
return ['alle' => 'Alle Medien', 'bild' => 'Bilder', 'film' => 'Filme', 'audio' => 'Hörstücke', 'dokument' => 'Dokumente'];
|
|
}
|
|
|
|
/**
|
|
* @return array{art: string, titel: string}
|
|
*/
|
|
public function pickerKontext(): array
|
|
{
|
|
return ['art' => (string) ($this->redaktionKopf()['fuer'] ?? 'das Objekt'), 'titel' => $this->redaktionTitel()];
|
|
}
|
|
|
|
public function pickerTitle(): string
|
|
{
|
|
return match ($this->pickerPurpose) {
|
|
'aufbau' => 'Bestandteil auswählen',
|
|
'austausch' => 'Medium austauschen',
|
|
default => 'Medien auswählen',
|
|
};
|
|
}
|
|
|
|
public function pickerConfirmLabel(): string
|
|
{
|
|
$count = count($this->pickerMarked);
|
|
|
|
return match ($this->pickerPurpose) {
|
|
'aufbau' => 'In den Aufbau übernehmen',
|
|
'austausch' => 'Austauschen',
|
|
default => $count === 1 ? '1 Medium übernehmen' : ($count === 0 ? 'Medien übernehmen' : $count.' Medien übernehmen'),
|
|
};
|
|
}
|
|
|
|
public function pickerReplacing(): ?array
|
|
{
|
|
if ($this->replacingKey === null) {
|
|
return null;
|
|
}
|
|
|
|
foreach ($this->presentationGroups() as $group) {
|
|
foreach ($group['rows'] as $row) {
|
|
if ($row['key'] === $this->replacingKey) {
|
|
return $row + ['role_label' => $group['label']];
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected function pickerExceptId(): int
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
protected function resetPicker(string $purpose): void
|
|
{
|
|
$this->pickerPurpose = $purpose;
|
|
$this->pickerOpen = true;
|
|
$this->pickerQuery = '';
|
|
$this->pickerDimension = '';
|
|
$this->pickerInspected = '';
|
|
$this->pickerSelected = '';
|
|
$this->pickerMarked = [];
|
|
$this->replacingKey = null;
|
|
$this->bindToVersion = false;
|
|
}
|
|
|
|
protected function defaultKindForRole(string $role): string
|
|
{
|
|
return match ($role) {
|
|
'titelbild', 'titelbild_alternativ', 'hero', 'hover', 'galerie' => 'bild',
|
|
'trailer', 'vorschauclip', 'interview' => 'film',
|
|
'audiovorschau' => 'audio',
|
|
default => 'alle',
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Ein Ziel in den Arbeitsstand der gewählten Rolle aufnehmen.
|
|
*/
|
|
protected function stageTarget(string $target): true|string
|
|
{
|
|
$elementId = $this->elementIdOf($target);
|
|
|
|
if ($elementId === null) {
|
|
return 'Präsentationsmedien sind Medien aus dem Bestand.';
|
|
}
|
|
|
|
$refusal = app(PresentationMedia::class)->refusal($this->editorialSubject(), $this->presentationRole, $elementId);
|
|
|
|
if ($refusal !== null) {
|
|
return $refusal;
|
|
}
|
|
|
|
foreach ($this->praesentation as $row) {
|
|
if ($row['role'] === $this->presentationRole && $row['element_id'] === $elementId) {
|
|
return '„'.($this->pickerMarked[$target] ?? 'Dieses Medium').'“ ist in dieser Rolle bereits zugeordnet.';
|
|
}
|
|
}
|
|
|
|
$row = [
|
|
'key' => 'n'.bin2hex(random_bytes(4)),
|
|
'id' => null,
|
|
'role' => $this->presentationRole,
|
|
'element_id' => $elementId,
|
|
'source' => $this->sourceFor($target),
|
|
];
|
|
|
|
if (! $this->roleAllowsMany($this->presentationRole)) {
|
|
$existing = $this->stagingIndexesOfRole($this->presentationRole);
|
|
|
|
if ($existing !== []) {
|
|
$this->praesentation[$existing[0]] = $row;
|
|
$this->praesentationFokus = $row['key'];
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
$this->insertStaged($row);
|
|
$this->praesentationFokus = $row['key'];
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function exchangeStaged(string $target): void
|
|
{
|
|
$index = $this->replacingKey !== null ? $this->stagingIndex($this->replacingKey) : null;
|
|
$elementId = $this->elementIdOf($target);
|
|
|
|
if ($index === null || $elementId === null) {
|
|
$this->closePicker();
|
|
$this->feedback('Diese Zuordnung gibt es nicht mehr.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$old = $this->praesentation[$index];
|
|
$refusal = app(PresentationMedia::class)->refusal($this->editorialSubject(), $old['role'], $elementId);
|
|
|
|
foreach ($this->praesentation as $other) {
|
|
if ($other['key'] !== $old['key'] && $other['role'] === $old['role'] && $other['element_id'] === $elementId) {
|
|
$refusal = 'Dieses Medium ist in dieser Rolle bereits zugeordnet.';
|
|
}
|
|
}
|
|
|
|
if ($refusal !== null) {
|
|
$this->feedback($refusal, true);
|
|
|
|
return;
|
|
}
|
|
|
|
$title = $this->pickerMarked[$target] ?? 'Das neue Medium';
|
|
$this->praesentation[$index] = [
|
|
'key' => $old['element_id'] === $elementId ? $old['key'] : 'n'.bin2hex(random_bytes(4)),
|
|
'id' => $old['element_id'] === $elementId ? $old['id'] : null,
|
|
'role' => $old['role'],
|
|
'element_id' => $elementId,
|
|
'source' => $old['element_id'] === $elementId ? $old['source'] : $this->sourceFor($target, $old['role']),
|
|
];
|
|
$this->praesentationFokus = $this->praesentation[$index]['key'];
|
|
$this->pickerOpen = false;
|
|
$this->pickerMarked = [];
|
|
$this->pickerSelected = '';
|
|
$this->pickerInspected = '';
|
|
$this->replacingKey = null;
|
|
$this->feedback('„'.$title.'“ ersetzt die bisherige Zuordnung an derselben Stelle. Wirksam wird das mit „Redaktion speichern“.');
|
|
}
|
|
|
|
protected function insertStaged(array $row): void
|
|
{
|
|
$order = array_keys($this->presentationRoleOptions());
|
|
$rank = array_search($row['role'], $order, true);
|
|
$insertAt = count($this->praesentation);
|
|
|
|
foreach ($this->praesentation as $index => $existing) {
|
|
$existingRank = array_search($existing['role'], $order, true);
|
|
|
|
if ($existingRank !== false && $rank !== false && $existingRank > $rank) {
|
|
$insertAt = $index;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
array_splice($this->praesentation, $insertAt, 0, [$row]);
|
|
$this->praesentation = array_values($this->praesentation);
|
|
}
|
|
|
|
protected function elementIdOf(string $target): ?int
|
|
{
|
|
if (preg_match('/^medium:(\d+)$/', $target, $match) === 1) {
|
|
return (int) $match[1];
|
|
}
|
|
|
|
if (preg_match('/^element:(\d+)$/', $target, $match) === 1) {
|
|
$id = ContentElementVersion::query()->whereKey((int) $match[1])->value('content_element_id');
|
|
|
|
return $id !== null ? (int) $id : null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected function sourceFor(string $target, ?string $role = null): ?int
|
|
{
|
|
$role ??= $this->presentationRole;
|
|
|
|
if (! $this->bindToVersion || ! in_array($role, PresentationRole::BOUND_ROLES, true)) {
|
|
return null;
|
|
}
|
|
|
|
$subject = $this->editorialSubject();
|
|
|
|
if ($subject instanceof ContentElement) {
|
|
$id = $subject->versions()->where('status', ContentVersionStatus::Bereit)->orderByDesc('number')->value('id');
|
|
|
|
return $id !== null ? (int) $id : null;
|
|
}
|
|
|
|
return preg_match('/^element:(\d+)$/', $target, $match) === 1 ? (int) $match[1] : null;
|
|
}
|
|
|
|
protected function stagingIndex(string $key): ?int
|
|
{
|
|
foreach ($this->praesentation as $index => $row) {
|
|
if ($row['key'] === $key) {
|
|
return $index;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @return list<int>
|
|
*/
|
|
protected function stagingIndexesOfRole(string $role): array
|
|
{
|
|
$indexes = [];
|
|
|
|
foreach ($this->praesentation as $index => $row) {
|
|
if ($row['role'] === $role) {
|
|
$indexes[] = $index;
|
|
}
|
|
}
|
|
|
|
return $indexes;
|
|
}
|
|
|
|
protected function roleIsOrdered(string $role): bool
|
|
{
|
|
return (bool) PresentationRole::query()->where('slug', $role)->value('ordered');
|
|
}
|
|
|
|
protected function roleAllowsMany(string $role): bool
|
|
{
|
|
return (bool) PresentationRole::query()->where('slug', $role)->value('multiple');
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $rows
|
|
*/
|
|
protected function stagingFingerprint(array $rows): string
|
|
{
|
|
return json_encode(array_map(
|
|
fn (array $row): array => [$row['id'], $row['role'], (int) $row['element_id'], $row['source']],
|
|
$rows,
|
|
), JSON_THROW_ON_ERROR);
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Abweichende Formulierungen (Arbeitsstand)
|
|
|
|
/**
|
|
* @return list<array{field: string, audience: string, body: string}>
|
|
*/
|
|
public function variantRows(): array
|
|
{
|
|
$this->loadRedaktionStaging();
|
|
|
|
return $this->varianten;
|
|
}
|
|
|
|
public function variantsUnsaved(): bool
|
|
{
|
|
if ($this->variantenGespeichert === null) {
|
|
return false;
|
|
}
|
|
|
|
return $this->variantFingerprint($this->varianten) !== $this->variantFingerprint($this->variantenGespeichert);
|
|
}
|
|
|
|
public function saveVariant(): void
|
|
{
|
|
$this->guardEditorial();
|
|
$this->loadRedaktionStaging();
|
|
$body = trim($this->variantBody);
|
|
|
|
if (! in_array($this->variantField, EditorialProfileReader::TEXT_FIELDS, true) || ! array_key_exists($this->variantAudience, EditorialProfileReader::AUDIENCES)) {
|
|
$this->feedback('Diese Abweichung ist nicht vorgesehen.', true);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->varianten = array_values(array_filter(
|
|
$this->varianten,
|
|
fn (array $row): bool => ! ($row['field'] === $this->variantField && $row['audience'] === $this->variantAudience),
|
|
));
|
|
|
|
if ($body !== '') {
|
|
$this->varianten[] = ['field' => $this->variantField, 'audience' => $this->variantAudience, 'body' => $body];
|
|
}
|
|
|
|
$this->variantBody = '';
|
|
$this->deskFeedback = '';
|
|
}
|
|
|
|
public function editVariant(string $field, string $audience): void
|
|
{
|
|
foreach ($this->varianten as $row) {
|
|
if ($row['field'] === $field && $row['audience'] === $audience) {
|
|
$this->variantField = $field;
|
|
$this->variantAudience = $audience;
|
|
$this->variantBody = $row['body'];
|
|
}
|
|
}
|
|
}
|
|
|
|
public function forgetVariant(string $field, string $audience): void
|
|
{
|
|
$this->guardEditorial();
|
|
$this->loadRedaktionStaging();
|
|
$this->varianten = array_values(array_filter(
|
|
$this->varianten,
|
|
fn (array $row): bool => ! ($row['field'] === $field && $row['audience'] === $audience),
|
|
));
|
|
}
|
|
|
|
public function variantFieldLabel(string $field): string
|
|
{
|
|
return match ($field) {
|
|
'display_title' => 'Anzeigename',
|
|
'teaser' => 'Teaser',
|
|
'summary' => 'Kurzbeschreibung',
|
|
'description' => 'Ausführliche Beschreibung',
|
|
default => $field,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @return list<array{field: string, audience: string, body: string}>
|
|
*/
|
|
protected function storedVariants(): array
|
|
{
|
|
$subject = $this->editorialSubject();
|
|
|
|
return EditorialTextVariant::query()
|
|
->where('subject_type', $subject->getMorphClass())
|
|
->where('subject_id', $subject->getKey())
|
|
->orderBy('audience')
|
|
->orderBy('field')
|
|
->get()
|
|
->map(fn (EditorialTextVariant $variant): array => [
|
|
'field' => (string) $variant->field,
|
|
'audience' => (string) $variant->audience,
|
|
'body' => (string) $variant->body,
|
|
])
|
|
->all();
|
|
}
|
|
|
|
protected function commitVariants(): void
|
|
{
|
|
$reader = app(EditorialProfileReader::class);
|
|
$subject = $this->editorialSubject();
|
|
$wanted = [];
|
|
|
|
foreach ($this->varianten as $row) {
|
|
$wanted[$row['field'].'|'.$row['audience']] = $row;
|
|
}
|
|
|
|
foreach ($this->variantenGespeichert ?? [] as $row) {
|
|
if (! isset($wanted[$row['field'].'|'.$row['audience']])) {
|
|
$reader->putVariant($subject, $row['field'], $row['audience'], null, $this->deskActor());
|
|
}
|
|
}
|
|
|
|
foreach ($wanted as $row) {
|
|
$reader->putVariant($subject, $row['field'], $row['audience'], $row['body'], $this->deskActor());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param list<array{field: string, audience: string, body: string}> $rows
|
|
*/
|
|
protected function variantFingerprint(array $rows): string
|
|
{
|
|
$keys = array_map(fn (array $row): string => $row['field'].'|'.$row['audience'].'|'.trim($row['body']), $rows);
|
|
sort($keys);
|
|
|
|
return implode("\n", $keys);
|
|
}
|
|
|
|
// ---------------------------------------------------------------- Hilfen
|
|
|
|
/**
|
|
* Fehlende zentrale Texte, für den Hinweis im Register Texte.
|
|
*
|
|
* @return list<string>
|
|
*/
|
|
public function editorialGaps(): array
|
|
{
|
|
$profile = $this->editorialProfile();
|
|
$gaps = [];
|
|
|
|
foreach (['display_title' => 'Anzeigename', 'teaser' => 'Teaser', 'summary' => 'Kurzbeschreibung', 'description' => 'Ausführliche Beschreibung'] as $field => $label) {
|
|
if ($profile->value($field) === null) {
|
|
$gaps[] = $label;
|
|
}
|
|
}
|
|
|
|
return $gaps;
|
|
}
|
|
|
|
protected function feedback(string $message, bool $error = false): void
|
|
{
|
|
$this->deskFeedback = $message;
|
|
$this->deskFeedbackError = $error;
|
|
}
|
|
|
|
protected function guardEditorial(): void
|
|
{
|
|
abort_unless($this->canEditEditorial(), 403);
|
|
}
|
|
|
|
protected function deskActor(): ?User
|
|
{
|
|
$user = auth()->user();
|
|
|
|
return $user instanceof User ? $user : null;
|
|
}
|
|
}
|