Stelle alle CMS-Bilder auf die zentrale Medienverwaltung um.
CI Feature / test (push) Successful in 48s
Deploy Test / test (push) Successful in 44s
Deploy Test / deploy (push) Successful in 37s

- Einstieg, Bild und Text, redaktionelle Karten, Premium-Karten und Abschnittshintergrund speichern die
  Kennung des Mediums (Bildschlüssel image) und lesen über WebsiteMedia; öffentlich nur mit Website-Freigabe,
  in der Redaktionsvorschau sonst das Vorschaubild mit Hinweis.
- Gemeinsame Felder: Medienpicker mit Vorschaubild und Status, Upload direkt über WebsiteIntake, Anzeige des
  gewählten Mediums mit Verweis auf den Medienmanager. Die CMS-eigene Bildauswahl entfällt.
- Frühere CMS-Bilder übernimmt ein Warteschlangen-Job (dedupliziert, nichts gelöscht); website_media_aliases
  ordnet frühere Pfade zu, wirksam erst nach der ersten Website-Freigabe; /medien/cms/ folgt danach der Freigabe.
- Medienansicht nennt die Website-Seiten, die ein Bild verwenden.
- Bewusst geändert: Der Alternativtext gehört zum Medium und ist im Widget nur noch eine optionale Abweichung;
  die Tests zur Alt-Text-Pflicht prüfen jetzt Übernahme und andere Registry-Fehler.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Opus 5.5 committed 2026-11-18 22:32:29 +01:00
1 parent 7c63424ea6
commit 053a8d4648
35 files changed
+1170 -164

No files matched your search

@@ -5,40 +5,80 @@
use App\Domain\Cms\Widgets\WidgetErrors;
use Filament\Forms\Components\Field;
use Filament\Forms\Components\FileUpload;
use Filament\Forms\Components\Placeholder;
use Filament\Forms\Components\Select;
use Illuminate\Support\Str;
use Filament\Notifications\Notification;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Illuminate\Support\HtmlString;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
/**
* Gemeinsame Bildauswahl für Widgets: vorhandenes Bild aus dem öffentlichen Website-Bereich wählen
* oder ein neues hochladen. Keine eigene Medienverwaltung.
* Gemeinsame Bildauswahl aller Widgets und des Abschnittshintergrunds: Bilder aus dem zentralen Medienmanager
* (siehe WebsiteImage, docs/architektur/medienzugriff-fuer-komponenten.md). Keine eigene CMS-Medienverwaltung.
*
* - Auswahl: durchsuchbare Liste mit Vorschaubild, Titel und Website-Status.
* - Neu hochladen: Das Bild wird sofort als Medium im Medienmanager angelegt (WebsiteIntake) und ausgewählt.
* - Anzeige des gewählten Mediums mit Status und Verweis auf die Freigabe im Medienmanager.
*
* Das Bedienmuster folgt der Bildauswahl im Modul- und Programmeditor (Suche, Vorschaubild, Auswählen); jene ist an
* die Livewire-Seite des Editors gebunden und lässt sich nicht als Formularfeld im Widget-Dialog einhängen.
*/
final class ImageRefFields
{
/**
* @param bool $live Änderungen sofort an die Vorschau im Bearbeitungsdialog geben.
* @return list<Field>
* @param string|null $altField Name des Alternativtext-Felds im selben Formular (für neue Medien), falls vorhanden.
* @return list<Field|Placeholder>
*/
public static function fields(string $label = 'Bild', bool $live = false): array
public static function fields(string $label = 'Bild', bool $live = false, string $key = 'image', ?string $altField = null): array
{
return [
Select::make('image')
->live($live)
->label($label.': vorhandenes Bild')
->options(fn (): array => PublicMedia::imageOptions())
Select::make($key)
->live()
->label($label.' aus dem Medienmanager')
->searchable()
->allowHtml()
->options(fn (): array => app(WebsiteImage::class)->options())
->getSearchResultsUsing(fn (?string $search): array => app(WebsiteImage::class)->options($search))
->getOptionLabelUsing(fn (mixed $value): ?string => app(WebsiteImage::class)->optionHtml($value))
->placeholder('Kein Bild')
->helperText('Auswahl aus den Bildern, die bereits für die Website hochgeladen wurden.'),
->helperText('Alle Bilder des Medienmanagers. Öffentlich erscheint ein Bild nur mit Website-Freigabe.'),
FileUpload::make('_upload')
->live($live)
->label($label.': neu hochladen')
->disk('cms_incoming')
->directory('cms')
->live()
->label($label.': neues Bild hochladen')
->image()
->maxSize(8192)
->acceptedFileTypes(['image/jpeg', 'image/png', 'image/webp'])
->getUploadedFileNameForStorageUsing(fn (TemporaryUploadedFile $file): string => Str::slug(pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)).'-'.Str::lower(Str::random(6)).'.'.$file->guessExtension())
->helperText('Ein neues Bild ersetzt die Auswahl oben. Es wird beim Speichern im öffentlichen Bereich der Website abgelegt.'),
->storeFiles(false)
->afterStateUpdated(function (mixed $state, Set $set, Get $get) use ($key, $altField): void {
$file = is_array($state) ? (array_values($state)[0] ?? null) : $state;
if (! $file instanceof TemporaryUploadedFile) {
return;
}
$element = app(WebsiteImage::class)->accept($file, $altField !== null ? $get($altField) : null);
$set('_upload', null);
if ($element === null) {
Notification::make()->danger()->title('Das Bild konnte nicht übernommen werden.')->send();
return;
}
$set($key, $element->id);
Notification::make()
->success()
->title('Im Medienmanager angelegt: „'.($element->display_title ?: $element->working_title).'“')
->body('Das Bild ist ausgewählt. Nach der Verarbeitung wird es automatisch für die Website freigegeben.')
->send();
})
->helperText('Das Bild wird im Medienmanager angelegt und hier ausgewählt. Nur Bilder mit geklärten Rechten hochladen.'),
Placeholder::make('_media_status')
->label('Gewähltes Bild')
->visible(fn (Get $get): bool => WebsiteImage::normalize($get($key)) !== null)
->content(fn (Get $get): HtmlString => self::statusHtml($get($key))),
];
}
@@ -48,29 +88,49 @@ public static function fields(string $label = 'Bild', bool $live = false): array
public static function rules(): array
{
return [
'image' => ['nullable', 'string', 'max:255'],
'image' => ['nullable'],
'_upload' => ['nullable'],
];
}
/**
* Übernimmt einen neuen Upload als Bild und prüft, dass das Bild im öffentlichen Bereich liegt.
* Prüft das gewählte Bild. Ein früherer CMS-Pfad mit wirksamer Zuordnung wird zur Kennung des Mediums.
* Ein noch als Datei übergebener Upload (frühere Formulare) wird über den Medienmanager aufgenommen.
*
* @param array<string, mixed> $refs
* @return array<string, mixed>
*/
public static function clean(array $refs, WidgetErrors $errors, string $key = 'image', ?string $errorKey = null): array
{
$upload = PublicMedia::fromUploadState($refs['_upload'] ?? null);
$image = $upload ?? PublicMedia::fromUploadState($refs[$key] ?? null);
$images = app(WebsiteImage::class);
$upload = $refs['_upload'] ?? null;
$upload = is_array($upload) ? (array_values($upload)[0] ?? null) : $upload;
if ($image !== null && ! PublicMedia::isPublicPath($image)) {
$errors->add($errorKey ?? "refs.$key", 'Das Bild liegt nicht im öffentlichen Medienbereich.');
if ($upload instanceof TemporaryUploadedFile) {
$element = $images->accept($upload);
$refs[$key] = $element?->id ?? $refs[$key] ?? null;
}
$refs[$key] = $image;
$refs[$key] = $images->clean($refs[$key] ?? null, $errors, $errorKey ?? "refs.$key");
unset($refs['_upload']);
return $refs;
}
public static function statusHtml(mixed $value): HtmlString
{
$status = app(WebsiteImage::class)->status($value);
if ($status === null) {
return new HtmlString('');
}
$thumb = $status['thumb'] !== null ? '<img src="'.e($status['thumb']).'" alt="">' : '';
$link = $status['manageUrl'] !== null
? '<a href="'.e($status['manageUrl']).'" target="_blank" rel="noopener">Im Medienmanager öffnen</a>'
: '';
return new HtmlString('<div class="luf-media-status luf-media-status-'.e($status['state']).'">'.$thumb
.'<div><strong>'.e($status['title']).'</strong><p>'.e($status['note']).'</p>'.$link.'</div></div>');
}
}
@@ -98,10 +98,10 @@ public static function focusFields(int $defaultX = 50, int $defaultY = 50): arra
public static function altField(): TextInput
{
return TextInput::make('alt')
->label('Alternativtext des Bildes')
->label('Alternativtext (optional)')
->maxLength(300)
->live(onBlur: true)
->helperText('Beschreibt, was auf dem Bild zu sehen ist. Pflicht, sobald ein Bild gewählt ist.');
->helperText('Leer lassen, dann gilt der Alternativtext des Mediums aus dem Medienmanager. Nur ausfüllen, wenn das Bild hier etwas anderes aussagen soll.');
}
/**
@@ -127,10 +127,6 @@ public static function clean(array $data, WidgetErrors $errors, bool $hasImage):
$data[$key] = is_numeric($value) ? (int) round(max(0, min(100, (float) $value))) : null;
}
if ($hasImage && $data['alt'] === null) {
$errors->add('data.alt', 'Bitte einen Alternativtext für das Bild angeben.');
}
return $data;
}
+2 -65
View File
@@ -2,20 +2,14 @@
namespace App\Domain\Cms\Widgets\Support;
use Illuminate\Support\Facades\Storage;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
use Throwable;
/**
* Öffentlicher Medienbereich der Website ("cms/"). Nur Dateien aus diesem Bereich dürfen in Widgets
* verwendet werden. Geschützte Bibliotheksmedien (Inhaltsdateien, Vorschaubilder) sind hier nie wählbar.
* Frühere öffentliche CMS-Bilder („cms/“, Route media.public). Neue Bilder kommen aus dem Medienmanager (WebsiteImage);
* dieser Bereich bleibt nur für gespeicherte Revisionen mit früheren Pfaden, die (noch) keinem Medium zugeordnet sind.
*/
final class PublicMedia
{
public const PREFIX = 'cms/';
private const IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'avif'];
public static function isPublicPath(mixed $path): bool
{
return is_string($path)
@@ -29,36 +23,6 @@ public static function url(string $path): string
return route('media.public', ['path' => $path]);
}
/**
* Bereits vorhandene Bilder im öffentlichen Bereich (veröffentlicht oder zur Veröffentlichung vorgemerkt).
*
* @return array<string, string>
*/
public static function imageOptions(): array
{
$options = [];
foreach (['media_public', 'cms_incoming'] as $disk) {
try {
$files = Storage::disk($disk)->allFiles(rtrim(self::PREFIX, '/'));
} catch (Throwable) {
$files = [];
}
foreach ($files as $file) {
$extension = strtolower(pathinfo($file, PATHINFO_EXTENSION));
if (self::isPublicPath($file) && in_array($extension, self::IMAGE_EXTENSIONS, true)) {
$options[$file] = substr($file, strlen(self::PREFIX));
}
}
}
ksort($options);
return $options;
}
/**
* Pfad aus dem Zustand eines Upload-Felds (Zeichenkette oder Liste).
*/
@@ -70,31 +34,4 @@ public static function fromUploadState(mixed $state): ?string
return is_string($state) && $state !== '' ? $state : null;
}
/**
* Bildadresse für Darstellung und Blockvorschau. In der Vorschau kann ein noch nicht gespeicherter Upload vorliegen.
*
* @param array<string, mixed> $refs
*/
public static function imageUrl(array $refs, string $key = 'image'): ?string
{
$upload = $refs['_upload'] ?? null;
$upload = is_array($upload) ? (array_values($upload)[0] ?? null) : $upload;
if ($upload instanceof TemporaryUploadedFile) {
try {
return $upload->temporaryUrl();
} catch (Throwable) {
return null;
}
}
if (self::isPublicPath($upload)) {
return self::url($upload);
}
$path = $refs[$key] ?? null;
return self::isPublicPath($path) ? self::url($path) : null;
}
}
@@ -0,0 +1,349 @@
<?php
namespace App\Domain\Cms\Widgets\Support;
use App\Domain\Catalog\ContentElement;
use App\Domain\Catalog\EditorialContentKind;
use App\Domain\Cms\Catalog\PublicMaterialReader;
use App\Domain\Cms\Widgets\WidgetErrors;
use App\Domain\Media\ThumbnailRef;
use App\Domain\Media\WebsiteIntake;
use App\Domain\Media\WebsiteMedia;
use App\Domain\Media\WebsiteMediaAlias;
use App\Domain\Media\WebsitePresentation;
use App\Filament\Resources\ContentElements\ContentElementResource;
use App\Models\User;
use Illuminate\Support\Str;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
use Throwable;
/**
* Bilder in CMS-Widgets und Abschnittshintergründen aus dem zentralen Medienbestand
* (docs/architektur/medienzugriff-fuer-komponenten.md).
*
* Gespeichert wird im jeweiligen Bildschlüssel (refs.image, style.image, data.items[].image) die Kennung des
* Inhaltselements (int). Frühere Werte sind Pfade unter cms/ (string):
* - mit wirksamer Zuordnung (WebsiteMediaAlias) gelten sie als das zugeordnete Medium,
* - ohne Zuordnung gelten sie weiter als öffentliches CMS-Bild (PublicMedia), bis das Widget umgestellt ist.
*
* Öffentlich erscheint ein Medium nur über WebsiteMedia (Website-Freigabe, Route website.media). In der
* Redaktionsvorschau erscheint ein nicht freigegebenes Bild als Vorschaubild der Bibliothek (Route editorial.card)
* mit Hinweis. Eine CMS-Verwendung gibt nichts frei.
*
* Je Anfrage gebunden (scoped): Ergebnisse werden innerhalb einer Anfrage zwischengespeichert.
*/
class WebsiteImage
{
/** @var array<string, int|string|null> */
private array $resolved = [];
/** @var array<int, WebsitePresentation|false> */
private array $presentations = [];
public function __construct(private readonly WebsiteMedia $media) {}
/**
* Gespeicherter oder eingegebener Wert → Kennung (int), früherer Pfad (string) oder null.
*/
public static function normalize(mixed $value): int|string|null
{
if (is_array($value)) {
$value = array_values($value)[0] ?? null;
}
if (is_int($value) && $value > 0) {
return $value;
}
if (is_string($value) && preg_match('/^[1-9][0-9]*$/', $value) === 1) {
return (int) $value;
}
return PublicMedia::isPublicPath($value) ? $value : null;
}
/**
* Kennung des Mediums: gespeicherte Kennung oder wirksam zugeordneter früherer Pfad; sonst null.
*/
public function elementId(mixed $value): ?int
{
$value = self::normalize($value);
if (is_int($value)) {
return $value;
}
if ($value === null) {
return null;
}
if (! array_key_exists($value, $this->resolved)) {
$this->resolved[$value] = WebsiteMediaAlias::effectiveFor($value)?->content_element_id;
}
$id = $this->resolved[$value];
return is_int($id) ? $id : null;
}
public function presentation(mixed $value): ?WebsitePresentation
{
$id = $this->elementId($value);
if ($id === null) {
return null;
}
if (! array_key_exists($id, $this->presentations)) {
$this->presentations[$id] = $this->media->present($id) ?? false;
}
return $this->presentations[$id] ?: null;
}
/**
* Bildadresse für die Darstellung. Öffentlich nur freigegebene Medien (oder frühere CMS-Bilder ohne Zuordnung);
* in der Redaktionsvorschau zusätzlich das Vorschaubild eines nicht freigegebenen Mediums.
*/
public function url(mixed $value, bool $preview = false): ?string
{
$presentation = $this->presentation($value);
if ($presentation !== null) {
return $presentation->kind === 'bild' ? $presentation->url : null;
}
$id = $this->elementId($value);
if ($id !== null) {
if (! $preview) {
return null;
}
$element = ContentElement::query()->find($id);
return $element === null ? null : ThumbnailRef::url('editorial.card', 'element', $element->id, $element->thumbnail_path);
}
$legacy = self::normalize($value);
return is_string($legacy) ? PublicMedia::url($legacy) : null;
}
/** Alternativtext: Angabe im Widget, sonst der Alternativtext des Mediums. */
public function alt(mixed $value, mixed $override = null): string
{
if (is_string($override) && trim($override) !== '') {
return trim($override);
}
return $this->presentation($value)?->alt ?? '';
}
/** Öffentliche Quellenzeile des Mediums (nur solange es freigegeben ist). */
public function credit(mixed $value): ?string
{
return $this->presentation($value)?->credit;
}
/**
* Hinweis für die Redaktionsvorschau, wenn das gewählte Bild öffentlich nicht erscheint; sonst null.
*/
public function previewNotice(mixed $value, string $label = 'Das gewählte Bild'): ?string
{
$status = $this->status($value);
if ($status === null || $status['public']) {
return null;
}
return $label.' „'.$status['title'].'“ erscheint öffentlich nicht: '.$status['note'];
}
/**
* Zustand für Editor und Vorschau.
*
* @return array{public: bool, state: string, title: string, note: string, thumb: ?string, manageUrl: ?string}|null
*/
public function status(mixed $value): ?array
{
$value = self::normalize($value);
if ($value === null) {
return null;
}
$id = $this->elementId($value);
if ($id === null) {
return [
'public' => true,
'state' => 'legacy',
'title' => basename((string) $value),
'note' => 'Früheres CMS-Bild, noch nicht in den Medienmanager übernommen.',
'thumb' => PublicMedia::url((string) $value),
'manageUrl' => null,
];
}
$element = ContentElement::query()->with('editorialContentKind')->find($id);
if ($element === null) {
return ['public' => false, 'state' => 'missing', 'title' => 'Medium '.$id, 'note' => 'Das Medium gibt es nicht mehr.', 'thumb' => null, 'manageUrl' => null];
}
$title = (string) ($element->display_title ?: $element->working_title);
$thumb = ThumbnailRef::url('editorial.card', 'element', $element->id, $element->thumbnail_path);
$manageUrl = ContentElementResource::getUrl('view', ['record' => $element]);
$public = $this->presentation($id) !== null;
$note = match (true) {
$public => 'Für die Website freigegeben.',
$element->archived_at !== null => 'Das Medium ist archiviert.',
filled($element->thumbnail_error) => 'Die Datei ließ sich nicht verarbeiten: '.Str::limit((string) $element->thumbnail_error, 120),
$element->thumbnail_path === null => 'Wird gerade verarbeitet. Danach wird es automatisch für die Website freigegeben.',
default => 'Nicht für die Website freigegeben. Die Freigabe steht im Medienmanager beim Medium unter „Beschreibung“ (Website-Freigabe).',
};
return [
'public' => $public,
'state' => $public ? 'released' : ($element->thumbnail_path === null && ! filled($element->thumbnail_error) ? 'pending' : 'unreleased'),
'title' => $title,
'note' => $note,
'thumb' => $thumb,
'manageUrl' => $manageUrl,
];
}
/**
* Prüft einen Wert beim Speichern. Ein früherer Pfad mit wirksamer Zuordnung wird zur Kennung des Mediums.
*/
public function clean(mixed $value, WidgetErrors $errors, string $errorKey): int|string|null
{
$raw = is_array($value) ? (array_values($value)[0] ?? null) : $value;
$value = self::normalize($raw);
if ($value === null) {
if ($raw !== null && $raw !== '') {
$errors->add($errorKey, 'Bitte ein Bild aus dem Medienmanager wählen.');
}
return null;
}
if (is_string($value)) {
return $this->elementId($value) ?? $value;
}
$element = ContentElement::query()->find($value);
if ($element === null || ! self::isSelectable($element)) {
$errors->add($errorKey, 'Dieses Medium ist kein Bild für die Website (nur Bilder aus dem Medienmanager, keine Traineranleitungen).');
return null;
}
return $element->id;
}
public static function isSelectable(ContentElement $element): bool
{
if ($element->output_class !== 'bild' || $element->archived_at !== null) {
return false;
}
$slug = $element->editorialContentKind?->slug
?? ($element->editorial_content_kind_id !== null ? EditorialContentKind::query()->whereKey($element->editorial_content_kind_id)->value('slug') : null);
return ! in_array($slug, PublicMaterialReader::CONFIDENTIAL_KINDS, true);
}
/**
* Auswahl für den Medienpicker: Bilder aus dem Medienmanager mit Vorschaubild, Titel und Freigabestatus (HTML).
*
* @return array<int, string>
*/
public function options(?string $search = null, int $limit = 60): array
{
$search = trim((string) $search);
$elements = ContentElement::query()
->with('editorialContentKind')
->where('output_class', 'bild')
->whereNull('archived_at')
->when($search !== '', function ($query) use ($search): void {
$like = '%'.mb_strtolower($search).'%';
$query->where(fn ($inner) => $inner
->whereRaw('LOWER(working_title) LIKE ?', [$like])
->orWhereRaw('LOWER(COALESCE(display_title, \'\')) LIKE ?', [$like]));
})
->orderByDesc('id')
->limit($limit)
->get();
$options = [];
foreach ($elements as $element) {
if (self::isSelectable($element)) {
$options[$element->id] = $this->optionHtml($element->id);
}
}
return $options;
}
/** HTML-Bezeichnung einer Option oder des gewählten Werts (auch für frühere Pfade). */
public function optionHtml(mixed $value): ?string
{
$status = $this->status($value);
if ($status === null) {
return null;
}
$badge = match ($status['state']) {
'released' => ['ok', 'Website: freigegeben'],
'pending' => ['wait', 'Wird verarbeitet'],
'legacy' => ['quiet', 'Früheres CMS-Bild'],
default => ['warn', 'Website: nicht freigegeben'],
};
$thumb = $status['thumb'] !== null
? '<img src="'.e($status['thumb']).'" alt="" loading="lazy">'
: '<span class="luf-media-option-empty" aria-hidden="true"></span>';
return '<span class="luf-media-option">'.$thumb
.'<span class="luf-media-option-text"><strong>'.e($status['title']).'</strong>'
.'<span class="luf-media-badge luf-media-badge-'.$badge[0].'">'.e($badge[1]).'</span></span></span>';
}
/**
* Neues Bild direkt aus dem CMS: Datei in den Eingang legen und über WebsiteIntake als Medium anlegen.
* Die Warteschlange leitet das Bild ab und gibt die Ableitung für die Website frei.
*/
public function accept(TemporaryUploadedFile $file, ?string $alt = null): ?ContentElement
{
$base = Str::slug(pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)) ?: 'bild';
$name = $base.'-'.Str::lower(Str::random(6)).'.'.($file->guessExtension() ?: 'jpg');
try {
$path = $file->storeAs('cms', $name, 'cms_incoming');
} catch (Throwable $exception) {
report($exception);
return null;
}
if (! is_string($path) || $path === '') {
return null;
}
$actor = auth('staff')->user();
return app(WebsiteIntake::class)->acceptImage(
$path,
Str::title(str_replace(['-', '_'], ' ', $base)),
null,
filled($alt) ? trim((string) $alt) : null,
$actor instanceof User ? $actor : null,
);
}
}