Files
laraundfelix/app/Filament/Support/EditorialCatalog.php
T
LarsandCursor f29ea58fd5
CI Feature / test (push) Successful in 54s
Deploy Test / test (push) Successful in 47s
Deploy Test / deploy (push) Successful in 24s
Ergänze die gemeinsame redaktionelle Basis an den Fachobjekten.
Texte, Materialart und Präsentationsmedien bleiben am Medium, Modul, Programm und Lizenzartikel und werden von Verwaltung und Karten aus derselben Quelle gelesen, ohne Fassung oder Lizenz zu verändern.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 07:54:36 +01:00

964 lines
35 KiB
PHP

<?php
namespace App\Filament\Support;
use App\Domain\Catalog\ArticleRelease;
use App\Domain\Catalog\Composition;
use App\Domain\Catalog\CompositionDisplayRelease;
use App\Domain\Catalog\CompositionKind;
use App\Domain\Catalog\CompositionMember;
use App\Domain\Catalog\CompositionVersion;
use App\Domain\Catalog\ContentElement;
use App\Domain\Catalog\ContentElementVersion;
use App\Domain\Catalog\ContentService;
use App\Domain\Catalog\ContentVersionStatus;
use App\Domain\Catalog\EditorialContentKind;
use App\Domain\Catalog\IdentityDimensionValue;
use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\OfferStatus;
use App\Domain\Cms\Catalog\PublicMaterialReader;
use App\Filament\Resources\Combinations\CombinationResource;
use App\Filament\Resources\ContentElements\ContentElementResource;
use App\Filament\Resources\Courses\CourseResource;
use App\Filament\Resources\Exercises\ExerciseResource;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;
class EditorialCatalog
{
/**
* @return list<array<string, string|null>>
*/
public function rows(CompositionVersion $version, int $exceptCompositionId): array
{
$version->loadMissing([
'members.contentElementVersion.element.editorialContentKind',
'members.nestedCompositionVersion.composition.editorialContentKind',
]);
$rows = [];
foreach ($version->members as $member) {
$target = $member->content_element_version_id
? 'element:'.$member->content_element_version_id
: 'composition:'.$member->nested_composition_version_id;
$row = $this->rowForTarget($target, $exceptCompositionId, allowSelf: true, allowDraft: true, allowBlocked: true);
if ($row === null) {
continue;
}
$row['role'] = $member->role;
$row['note'] = trim((string) ($member->placement_note ?? ''));
$rows[] = $row;
}
return $rows;
}
/**
* @return array<string, string|null>|null
*/
public function rowForTarget(string $target, int $exceptCompositionId, bool $allowSelf = false, bool $allowDraft = false, bool $allowBlocked = false): ?array
{
if (preg_match('/^composition-draft:(\d+)$/', $target, $draftMatch) === 1) {
return $this->draftCompositionRow((int) $draftMatch[1], $exceptCompositionId, $allowSelf);
}
if (preg_match('/^(element|composition):(\d+)$/', $target, $match) !== 1) {
return null;
}
if ($match[1] === 'element') {
$version = ContentElementVersion::query()
->with('element.editorialContentKind')
->find($match[2]);
$acceptable = [ContentVersionStatus::Bereit];
if ($allowDraft) {
$acceptable[] = ContentVersionStatus::Entwurf;
}
if ($allowBlocked) {
$acceptable[] = ContentVersionStatus::Gesperrt;
}
if (! $version instanceof ContentElementVersion || ! in_array($version->status, $acceptable, true)) {
return null;
}
$element = $version->element;
$kind = $element->editorialContentKind?->label ?: $this->outputLabel((string) $element->output_class);
$title = filled($element->display_title) ? $element->display_title : $element->working_title;
return [
'target' => 'element:'.$version->id,
'element_id' => (string) $element->id,
'title' => $title,
'kind' => $kind,
'output' => (string) $element->output_class,
'body' => (string) ($version->body ?? ''),
'summary' => (string) ($element->summary ?: $element->description ?: ''),
'medium_description' => (string) ($element->description ?? ''),
'usage_note' => (string) ($element->usage_note ?? ''),
'license_note' => (string) ($element->license_note ?? ''),
'tone' => $this->tone((string) $element->output_class, $kind),
'image' => $this->cardUrl('element', $element->id, $element->thumbnail_path),
'version_label' => match ($version->status) {
ContentVersionStatus::Entwurf => 'Entwurf',
ContentVersionStatus::Gesperrt => 'deaktiviert',
default => 'Fassung '.$version->number,
},
'committed' => app(ContentService::class)->isCommitted($version),
'identity' => 'medium:'.$element->id,
'open_url' => route('content.preview', $version),
'open_label' => 'Medium ansehen',
'edit_url' => ContentElementResource::getUrl('view', ['record' => $element]),
];
}
$version = CompositionVersion::query()
->with('composition.editorialContentKind')
->find($match[2]);
$acceptable = [ContentVersionStatus::Bereit];
if ($allowBlocked) {
$acceptable[] = ContentVersionStatus::Gesperrt;
}
if (! $version instanceof CompositionVersion || ! in_array($version->status, $acceptable, true)) {
return null;
}
if (! $allowSelf && (int) $version->composition_id === $exceptCompositionId) {
return null;
}
$composition = $version->composition;
$kind = $composition->editorialContentKind?->label
?: ($composition->kind instanceof CompositionKind ? $composition->kind->deskLabel() : 'Zusammenstellung');
return [
'target' => 'composition:'.$version->id,
'title' => $this->compositionTitle($composition),
'kind' => $kind,
'summary' => (string) ($composition->summary ?? ''),
'tone' => $this->tone('', $kind),
'image' => $this->cardUrl('komposition', $composition->id, $composition->thumbnail_path),
'version_label' => $version->status === ContentVersionStatus::Gesperrt
? 'deaktiviert'
: 'Fassung '.$version->number,
'identity' => 'zusammenstellung:'.$composition->id,
'open_url' => route('editorial.preview', ['composition' => $composition, 'version' => $version]),
'open_label' => 'Aufbau ansehen',
'edit_url' => self::editUrl($composition),
];
}
/**
* @return array<string, string|null>|null
*/
private function draftCompositionRow(int $compositionId, int $exceptCompositionId, bool $allowSelf): ?array
{
if (! $allowSelf && $compositionId === $exceptCompositionId) {
return null;
}
$composition = Composition::query()->with('editorialContentKind')->find($compositionId);
if (! $composition instanceof Composition) {
return null;
}
$kind = $composition->editorialContentKind?->label
?: ($composition->kind instanceof CompositionKind ? $composition->kind->deskLabel() : 'Zusammenstellung');
return [
'target' => 'composition-draft:'.$composition->id,
'title' => $this->compositionTitle($composition),
'kind' => $kind,
'summary' => (string) ($composition->summary ?? ''),
'tone' => $this->tone('', $kind),
'image' => $this->cardUrl('komposition', $composition->id, $composition->thumbnail_path),
'version_label' => 'Entwurf',
'identity' => 'zusammenstellung:'.$composition->id,
'open_url' => route('editorial.draft-preview', ['composition' => $composition]),
'open_label' => 'Entwurf ansehen',
'edit_url' => self::editUrl($composition),
];
}
/**
* @return list<array<string, string|null>>
*/
public function search(string $query, string $scope, int $exceptCompositionId): array
{
$query = trim($query);
$like = '%'.str_replace(['%', '_'], ['', ''], $query).'%';
$limit = $scope === 'alles' ? 20 : 40;
$rows = [];
if ($scope !== 'module') {
$elements = ContentElementVersion::query()
->where('status', ContentVersionStatus::Bereit)
->with('element.editorialContentKind')
->whereHas('element', function ($builder) use ($query, $like): void {
if ($query === '') {
return;
}
$builder->where('working_title', 'like', $like)
->orWhere('display_title', 'like', $like)
->orWhere('teaser', 'like', $like)
->orWhere('search_terms', 'like', $like)
->orWhere('summary', 'like', $like);
})
->orderByDesc('id')
->limit($limit)
->get();
foreach ($elements as $version) {
$row = $this->rowForTarget('element:'.$version->id, $exceptCompositionId);
if ($row !== null) {
$rows[] = $row;
}
}
}
if ($scope !== 'medien') {
$versions = CompositionVersion::query()
->where('status', ContentVersionStatus::Bereit)
->where('composition_id', '!=', $exceptCompositionId)
->with('composition.editorialContentKind')
->whereHas('composition', function ($builder) use ($scope, $query, $like): void {
if ($scope === 'module') {
$builder->where('kind', CompositionKind::Uebung);
}
if ($query === '') {
return;
}
$builder->where(function ($inner) use ($like): void {
$inner->where('designation', 'like', $like)
->orWhere('display_title', 'like', $like)
->orWhere('teaser', 'like', $like)
->orWhere('search_terms', 'like', $like)
->orWhere('summary', 'like', $like);
});
})
->orderByDesc('id')
->limit($limit)
->get();
foreach ($versions as $version) {
$row = $this->rowForTarget('composition:'.$version->id, $exceptCompositionId);
if ($row !== null) {
$rows[] = $row;
}
}
}
return array_slice($rows, 0, 40);
}
/**
* @return array{items: list<array<string, string|null>>, more: bool}
*/
public function browse(string $query, string $kind, string $dimension, int $exceptCompositionId, bool $elementsOnly = false): array
{
$query = trim($query);
$like = '%'.str_replace(['%', '_'], ['', ''], $query).'%';
$limit = 48;
$rows = [];
$dimensionId = ctype_digit($dimension) ? (int) $dimension : 0;
if ($kind !== 'modul') {
$latestElements = ContentElementVersion::query()
->selectRaw('MAX(id)')
->whereIn('status', [ContentVersionStatus::Bereit, ContentVersionStatus::Entwurf])
->whereHas('element', function ($builder) use ($query, $like, $kind, $dimensionId): void {
$this->constrainElement($builder, $query, $like, $kind, $dimensionId);
})
->groupBy('content_element_id');
$elements = ContentElementVersion::query()
->with('element.editorialContentKind')
->whereIn('id', $latestElements)
->orderByDesc('id')
->limit($limit + 1)
->get();
foreach ($elements as $version) {
$row = $this->rowForTarget('element:'.$version->id, $exceptCompositionId, allowDraft: true);
if ($row !== null) {
$rows[] = $row;
}
}
}
if (! $elementsOnly && in_array($kind, ['alle', 'modul'], true)) {
$latestCompositions = CompositionVersion::query()
->selectRaw('MAX(id)')
->where('status', ContentVersionStatus::Bereit)
->where('composition_id', '!=', $exceptCompositionId)
->whereHas('composition', function ($builder) use ($query, $like, $kind, $dimensionId): void {
if ($kind === 'modul') {
$builder->where('kind', CompositionKind::Uebung);
}
if ($dimensionId > 0) {
$builder->whereIn('id', $this->dimensionSubjectIds(Composition::class, $dimensionId));
}
if ($query === '') {
return;
}
$builder->where(function ($inner) use ($like): void {
$inner->where('designation', 'like', $like)
->orWhere('display_title', 'like', $like)
->orWhere('teaser', 'like', $like)
->orWhere('search_terms', 'like', $like)
->orWhere('summary', 'like', $like);
});
})
->groupBy('composition_id');
$versions = CompositionVersion::query()
->with('composition.editorialContentKind')
->whereIn('id', $latestCompositions)
->orderByDesc('id')
->limit($limit + 1)
->get();
foreach ($versions as $version) {
$row = $this->rowForTarget('composition:'.$version->id, $exceptCompositionId);
if ($row !== null) {
$rows[] = $row;
}
}
$unreleased = Composition::query()
->where('id', '!=', $exceptCompositionId)
->whereNotNull('working_draft')
->whereDoesntHave('versions', function ($builder): void {
$builder->where('status', ContentVersionStatus::Bereit);
})
->when($kind === 'modul', function ($builder): void {
$builder->where('kind', CompositionKind::Uebung);
})
->orderByDesc('id')
->get();
foreach ($unreleased as $composition) {
$draft = is_array($composition->working_draft) ? $composition->working_draft : [];
$draftMembers = is_array($draft['members'] ?? null) ? $draft['members'] : [];
if ($draftMembers === []) {
continue;
}
if ($dimensionId > 0 && ! in_array($composition->id, $this->dimensionSubjectIds(Composition::class, $dimensionId), true)) {
continue;
}
$title = $this->compositionTitle($composition);
if ($query !== '' && ! str_contains(mb_strtolower($title.' '.(string) ($composition->summary ?? '')), mb_strtolower($query))) {
continue;
}
$row = $this->rowForTarget('composition-draft:'.$composition->id, $exceptCompositionId);
if ($row !== null) {
$rows[] = $row;
}
}
}
$rows = $this->withVisibility($rows);
return [
'items' => array_slice($rows, 0, $limit),
'more' => count($rows) > $limit,
];
}
public function tone(string $outputClass, string $kindLabel): string
{
$value = mb_strtolower($outputClass.' '.$kindLabel);
return match (true) {
str_contains($value, 'film') => 'film',
str_contains($value, 'hör'), str_contains($value, 'audio') => 'audio',
str_contains($value, 'dokument'), str_contains($value, 'pdf') => 'dokument',
str_contains($value, 'modul'), str_contains($value, 'programm') => 'modul',
default => 'text',
};
}
public function cardUrl(string $kind, int $id, ?string $path): ?string
{
if (! is_string($path) || ! str_starts_with($path, 'vorschau/') || str_contains($path, '..')) {
return null;
}
return route('editorial.card', ['kind' => $kind, 'subject' => $id]);
}
/**
* @param list<array<string, mixed>> $rows
* @return list<array<string, mixed>>
*/
private function withVisibility(array $rows): array
{
$ids = [];
foreach ($rows as $row) {
if (isset($row['element_id'])) {
$ids[] = (int) $row['element_id'];
}
}
if ($ids === []) {
return $rows;
}
$reader = app(PublicMaterialReader::class);
$elements = ContentElement::query()
->with('editorialContentKind')
->whereIn('id', array_values(array_unique($ids)))
->get()
->keyBy('id');
foreach ($rows as $index => $row) {
$element = $elements->get((int) ($row['element_id'] ?? 0));
if ($element instanceof ContentElement) {
$rows[$index]['visibility'] = $reader->visibilityNote($element);
}
}
return $rows;
}
/**
* @param Builder<ContentElement> $builder
*/
private function constrainElement($builder, string $query, string $like, string $kind, int $dimensionId): void
{
$outputs = match ($kind) {
'film' => ['film'],
'text' => ['text'],
'bild' => ['bild'],
'dokument' => ['pdf', 'document'],
default => null,
};
if ($outputs !== null) {
$builder->whereIn('output_class', $outputs);
}
if ($dimensionId > 0) {
$builder->whereIn('id', $this->dimensionSubjectIds(ContentElement::class, $dimensionId));
}
if ($query === '') {
return;
}
$builder->where(function ($inner) use ($like): void {
$inner->where('working_title', 'like', $like)
->orWhere('display_title', 'like', $like)
->orWhere('teaser', 'like', $like)
->orWhere('search_terms', 'like', $like)
->orWhere('summary', 'like', $like)
->orWhere('description', 'like', $like);
});
}
/**
* @param class-string<Model> $class
* @return list<int>
*/
private function dimensionSubjectIds(string $class, int $dimensionId): array
{
return IdentityDimensionValue::query()
->where('subject_type', (new $class)->getMorphClass())
->where('editorial_dimension_value_id', $dimensionId)
->where('origin', 'direkt')
->pluck('subject_id')
->map(fn (mixed $id): int => (int) $id)
->all();
}
/**
* @return list<array{target: string, label: string}>
*/
public function alternatives(string $identity, int $exceptCompositionId): array
{
if (preg_match('/^(medium|zusammenstellung):(\d+)$/', $identity, $match) !== 1) {
return [];
}
$options = [];
if ($match[1] === 'medium') {
$versions = ContentElementVersion::query()
->where('content_element_id', $match[2])
->whereIn('status', [ContentVersionStatus::Bereit, ContentVersionStatus::Entwurf])
->orderBy('number')
->get();
foreach ($versions as $version) {
$options[] = [
'target' => 'element:'.$version->id,
'label' => $version->status === ContentVersionStatus::Entwurf ? 'Entwurf' : 'Fassung '.$version->number,
];
}
return $options;
}
if ((int) $match[2] === $exceptCompositionId) {
return [];
}
$versions = CompositionVersion::query()
->where('composition_id', $match[2])
->where('status', ContentVersionStatus::Bereit)
->orderBy('number')
->get();
foreach ($versions as $version) {
$options[] = [
'target' => 'composition:'.$version->id,
'label' => 'Fassung '.$version->number,
];
}
return $options;
}
public function defaultRole(string $kind): string
{
$kind = mb_strtolower($kind);
return match (true) {
str_contains($kind, 'film') => 'Film',
str_contains($kind, 'hör') || str_contains($kind, 'audio') => 'Hörstück',
str_contains($kind, 'modul') => 'Modul',
str_contains($kind, 'programm') => 'Programm',
str_contains($kind, 'text'), str_contains($kind, 'dokument'), str_contains($kind, 'merkblatt'), str_contains($kind, 'unterlage') => 'Unterlage',
default => 'Bestandteil',
};
}
/**
* @return list<string>
*/
public function usage(CompositionVersion $version): array
{
$lines = [];
$parents = CompositionMember::query()
->where('nested_composition_version_id', $version->id)
->with('compositionVersion.composition')
->get();
foreach ($parents as $member) {
$parent = $member->compositionVersion?->composition;
$name = $parent instanceof Composition ? $this->compositionTitle($parent) : 'Zusammenstellung';
$lines[] = $name.', Rolle '.$member->role;
}
$articles = ArticleRelease::query()
->where('root_composition_version_id', $version->id)
->with('article')
->get();
foreach ($articles as $release) {
$lines[] = 'Lizenzartikel '.$release->article->code.', Stand '.$release->number;
}
return $lines;
}
/**
* @return array{text: string, number: int|null, released_number: int|null}
*/
public function stand(Composition $composition): array
{
$ready = $composition->versions
->filter(fn (CompositionVersion $version): bool => $version->status === ContentVersionStatus::Bereit)
->sortByDesc('number')
->values();
$latest = $ready->first();
$release = app(CompositionDisplayRelease::class);
$released = $ready->first(fn (CompositionVersion $version): bool => $release->isReleased($version));
$draft = is_array($composition->working_draft) && $composition->working_draft !== [];
if (! $latest instanceof CompositionVersion) {
return [
'text' => $draft ? 'Entwurf gespeichert' : 'Noch ohne Fassung',
'number' => null,
'released_number' => $released instanceof CompositionVersion ? $released->number : null,
];
}
$visible = $released instanceof CompositionVersion;
$text = 'Fassung '.$latest->number.($visible ? ', in der Mitgliederbibliothek' : ', nicht in der Mitgliederbibliothek');
$text = ($draft ? 'Entwurf gespeichert. ' : '').$text;
if ($visible && $released->number !== $latest->number) {
$text .= '. Angezeigt wird Fassung '.$released->number;
}
return [
'text' => $text,
'number' => $latest->number,
'released_number' => $visible ? $released->number : null,
];
}
/**
* @return list<array{label: string, tone: string}>
*/
public function statusChips(Composition $composition, bool $offered): array
{
$stand = $this->stand($composition);
$chips = [];
if ($stand['number'] === null) {
$chips[] = [
'label' => str_contains($stand['text'], 'Entwurf') ? 'Entwurf gespeichert' : 'Noch ohne Fassung',
'tone' => 'yellow',
];
} else {
$chips[] = ['label' => 'Fassung '.$stand['number'], 'tone' => 'ink'];
if (str_starts_with($stand['text'], 'Entwurf gespeichert')) {
$chips[] = ['label' => 'Entwurf offen', 'tone' => 'yellow'];
}
$chips[] = $stand['released_number'] !== null
? ['label' => 'In der Mitgliederbibliothek', 'tone' => 'pine']
: ['label' => 'Nicht in der Mitgliederbibliothek', 'tone' => 'quiet'];
if ($stand['released_number'] !== null && $stand['released_number'] !== $stand['number']) {
$chips[] = ['label' => 'Bibliothek zeigt Fassung '.$stand['released_number'], 'tone' => 'pine'];
}
}
$chips[] = ['label' => 'Nicht auf der Website', 'tone' => 'quiet'];
$chips[] = $offered
? ['label' => 'Angebot aktiv', 'tone' => 'pine']
: ['label' => 'Kein aktives Angebot', 'tone' => 'quiet'];
return $chips;
}
/**
* @return list<int>
*/
public function offeredCompositionIds(): array
{
$articleIds = DB::table('resolved_scopes')
->join('offer_versions', 'offer_versions.id', '=', 'resolved_scopes.offer_version_id')
->where('offer_versions.status', OfferStatus::Aktiv->value)
->pluck('resolved_scopes.license_article_id');
if ($articleIds->isEmpty()) {
return [];
}
$releaseIds = LicenseArticle::query()
->whereIn('id', $articleIds)
->whereNotNull('current_release_id')
->pluck('current_release_id');
$versionIds = ArticleRelease::query()
->whereIn('id', $releaseIds)
->whereNotNull('root_composition_version_id')
->pluck('root_composition_version_id');
return CompositionVersion::query()
->whereIn('id', $versionIds)
->pluck('composition_id')
->map(fn (mixed $id): int => (int) $id)
->unique()
->values()
->all();
}
/**
* @param list<array<string, mixed>> $members
* @return list<array{id: int, title: string, image: string}>
*/
public function filmPictures(array $members): array
{
$versionIds = [];
foreach ($members as $member) {
$target = (string) ($member['target'] ?? '');
if (preg_match('/^element:(\d+)$/', $target, $match) === 1) {
$versionIds[] = (int) $match[1];
}
}
if ($versionIds === []) {
return [];
}
$pictures = [];
foreach (ContentElementVersion::query()->with('element')->whereIn('id', $versionIds)->get() as $version) {
$element = $version->element;
if (! $element instanceof ContentElement || $element->output_class !== 'film') {
continue;
}
$image = $this->cardUrl('element', $element->id, $element->thumbnail_path);
if ($image === null || isset($pictures[$element->id])) {
continue;
}
$pictures[$element->id] = [
'id' => $element->id,
'title' => filled($element->display_title) ? $element->display_title : $element->working_title,
'image' => $image,
];
}
return array_values($pictures);
}
/**
* @return list<array{id: int, title: string, image: string, kind: string}>
*/
public function mediaPictures(string $query): array
{
$query = trim($query);
if (mb_strlen($query) < 2) {
return [];
}
$like = '%'.str_replace(['%', '_'], ['', ''], $query).'%';
return ContentElement::query()
->where('thumbnail_path', 'like', 'vorschau/%')
->where(function ($builder) use ($like): void {
$builder->where('working_title', 'like', $like)
->orWhere('display_title', 'like', $like)
->orWhere('teaser', 'like', $like)
->orWhere('search_terms', 'like', $like)
->orWhere('summary', 'like', $like);
})
->orderBy('working_title')
->limit(12)
->get()
->map(function (ContentElement $element): ?array {
$image = $this->cardUrl('element', $element->id, $element->thumbnail_path);
if ($image === null) {
return null;
}
return [
'id' => $element->id,
'title' => filled($element->display_title) ? $element->display_title : $element->working_title,
'image' => $image,
'kind' => $element->editorialContentKind?->label ?: $this->outputLabel((string) $element->output_class),
];
})
->filter()
->values()
->all();
}
/**
* @param list<array<string, mixed>> $members
* @return array{url: ?string, note: ?string, own: bool}
*/
public function cover(Composition $composition, array $members): array
{
$own = $this->cardUrl('komposition', $composition->id, $composition->thumbnail_path);
if ($own !== null) {
return ['url' => $own, 'note' => null, 'own' => true];
}
$picture = $this->suggestPicture($members);
if ($picture === null) {
return ['url' => null, 'note' => null, 'own' => false];
}
return [
'url' => $this->cardUrl($picture['kind'], $picture['subject'], 'vorschau/gesetzt'),
'note' => $picture['note'],
'own' => false,
];
}
/**
* Das eigene Titelbild, sonst das erste Vorschaubild aus dem freigegebenen Aufbau.
*
* @return array{kind: string, subject: int, alt: string, note: string}|null
*/
public function visiblePicture(Composition $composition, ?CompositionVersion $version): ?array
{
if ($this->cardUrl('komposition', $composition->id, $composition->thumbnail_path) !== null) {
return [
'kind' => 'komposition',
'subject' => $composition->id,
'alt' => filled($composition->thumbnail_alt) ? (string) $composition->thumbnail_alt : $this->compositionTitle($composition),
'note' => '',
];
}
if ($version === null) {
return null;
}
$version->loadMissing('members');
$members = [];
foreach ($version->members as $member) {
$members[] = [
'target' => $member->content_element_version_id
? 'element:'.$member->content_element_version_id
: 'composition:'.$member->nested_composition_version_id,
];
}
return $this->suggestPicture($members);
}
/**
* @param list<array<string, mixed>> $members
* @param list<int> $seen
* @return array{kind: string, subject: int, alt: string, note: string}|null
*/
private function suggestPicture(array $members, array $seen = []): ?array
{
foreach ($members as $member) {
$target = (string) ($member['target'] ?? '');
if (preg_match('/^element:(\d+)$/', $target, $match) === 1) {
$version = ContentElementVersion::query()->with('element')->find((int) $match[1]);
$element = $version?->element;
if (! $element instanceof ContentElement || $this->cardUrl('element', $element->id, $element->thumbnail_path) === null) {
continue;
}
$title = filled($element->display_title) ? $element->display_title : $element->working_title;
return [
'kind' => 'element',
'subject' => $element->id,
'alt' => filled($element->thumbnail_alt) ? (string) $element->thumbnail_alt : $title,
'note' => $element->output_class === 'film'
? 'Vorschlag aus dem Film '.$title
: 'Vorschlag aus '.$title,
];
}
if (preg_match('/^composition:(\d+)$/', $target, $match) !== 1 || in_array((int) $match[1], $seen, true)) {
continue;
}
$version = CompositionVersion::query()->with('composition', 'members')->find((int) $match[1]);
if (! $version instanceof CompositionVersion) {
continue;
}
$nested = $version->composition;
if ($this->cardUrl('komposition', $nested->id, $nested->thumbnail_path) !== null) {
return [
'kind' => 'komposition',
'subject' => $nested->id,
'alt' => filled($nested->thumbnail_alt) ? (string) $nested->thumbnail_alt : $this->compositionTitle($nested),
'note' => 'Vorschlag aus '.$this->compositionTitle($nested),
];
}
$children = [];
foreach ($version->members as $child) {
$children[] = [
'target' => $child->content_element_version_id
? 'element:'.$child->content_element_version_id
: 'composition:'.$child->nested_composition_version_id,
];
}
$picture = $this->suggestPicture($children, [...$seen, $version->id]);
if ($picture !== null) {
return $picture;
}
}
return null;
}
public function create(string $designation, CompositionKind $kind): Composition
{
$composition = app(ContentService::class)->createComposition($designation, $kind);
$slug = match ($kind) {
CompositionKind::Kurs => 'programm',
CompositionKind::Uebung => 'modul',
default => null,
};
$editorial = $slug === null ? null : EditorialContentKind::query()->where('slug', $slug)->first();
if ($editorial !== null) {
$composition->editorial_content_kind_id = $editorial->id;
$composition->save();
}
return $composition;
}
public static function editUrl(Composition $composition): string
{
$kind = $composition->kind instanceof CompositionKind
? $composition->kind
: CompositionKind::from((string) $composition->kind);
$resource = match ($kind) {
CompositionKind::Kurs => CourseResource::class,
CompositionKind::Kombination => CombinationResource::class,
CompositionKind::Uebung => ExerciseResource::class,
};
return $resource::getUrl('edit', ['record' => $composition]);
}
public function compositionTitle(Composition $composition): string
{
return filled($composition->display_title) ? $composition->display_title : $composition->designation;
}
public function outputLabel(string $outputClass): string
{
return match ($outputClass) {
'film' => 'Film',
'audio' => 'Hörstück',
'bild' => 'Bild',
'document', 'pdf' => 'Dokument',
default => 'Text',
};
}
}