Files
ersatztv/web/src/screens/DecosScreen.tsx
T
timothyandClaude Fable 5 a52939f292 feat(web): Decos screen (list + 6-section editor) on the REST API (#144 S3 (#162))
Adds the /app/decos screen (dual-mode list/editor) mirroring the legacy Blazor
deco form: deco/watermark/graphics/break-content/default-filler/dead-air
sections with mode-gated controls, watermark/graphics multi-selects, break
content with a playlist group->playlist cascade and per-placement uniqueness,
and default-filler/dead-air typeahead pickers. Adds decos/playlists api modules,
artist/multi-collection search wrappers, and regenerated types.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-07 19:22:49 +02:00

1232 lines
40 KiB
TypeScript

import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
import { ArrowLeft, Check, FolderPlus, Palette, Plus, Trash2, TriangleAlert } from 'lucide-react';
import { navigateToPath } from '../routing';
import {
Badge,
Button,
Card,
Checkbox,
ConfirmDialog,
Dialog,
IconButton,
Input,
Select,
Spinner
} from '../components';
import {
createDeco,
createDecoGroup,
deleteDeco,
deleteDecoGroup,
getDeco,
getDecoGroups,
getDecos,
messageFromDecoError,
replaceDeco,
searchArtists,
searchCollections,
searchMultiCollections,
searchSmartCollections,
searchTelevisionSeasons,
searchTelevisionShows,
type Deco,
type DecoBreakContentRequest,
type DecoGroup,
type DecoListItem,
type ReplaceDecoRequest,
type SchedulingPickerOption
} from '../api';
import { getGraphicsElements, getWatermarks, type GraphicsElement, type Watermark } from '../api/pickers';
import { getPlaylistGroups, getPlaylists, type Playlist, type PlaylistGroup } from '../api/playlists';
const BASE_PATH = '/app/decos';
type DecoMode = ReplaceDecoRequest['watermarkMode'];
type CollectionType = DecoBreakContentRequest['collectionType'];
type BreakPlacement = DecoBreakContentRequest['placement'];
// Watermark + graphics sections offer Merge and label Override as "Replace" (mirrors Blazor DecoEditor).
const WATERMARK_MODE_OPTIONS: Array<{ label: string; value: DecoMode }> = [
{ label: 'Inherit', value: 'Inherit' },
{ label: 'Disable', value: 'Disable' },
{ label: 'Replace', value: 'Override' },
{ label: 'Merge', value: 'Merge' }
];
// Break content / default filler / dead air offer only Inherit / Disable / Override (no Merge).
const BASIC_MODE_OPTIONS: Array<{ label: string; value: DecoMode }> = [
{ label: 'Inherit', value: 'Inherit' },
{ label: 'Disable', value: 'Disable' },
{ label: 'Override', value: 'Override' }
];
// Default filler / dead air fallback collection types (mirrors Blazor; no Playlist here).
const FILLER_TYPE_OPTIONS: Array<{ label: string; value: CollectionType }> = [
{ label: 'Collection', value: 'Collection' },
{ label: 'Television Show', value: 'TelevisionShow' },
{ label: 'Television Season', value: 'TelevisionSeason' },
{ label: 'Artist', value: 'Artist' },
{ label: 'Multi Collection', value: 'MultiCollection' },
{ label: 'Smart Collection', value: 'SmartCollection' }
];
const PLACEMENT_OPTIONS: Array<{ label: string; value: BreakPlacement }> = [
{ label: 'Block Start', value: 'BlockStart' },
{ label: 'Block Finish', value: 'BlockFinish' },
{ label: 'Between Block Items', value: 'BetweenBlockItems' },
{ label: 'At Chapter Markers', value: 'ChapterMarkers' }
];
function placementLabel(value: BreakPlacement): string {
return PLACEMENT_OPTIONS.find((o) => o.value === value)?.label ?? value;
}
function fillerTypeLabel(value: CollectionType): string {
return FILLER_TYPE_OPTIONS.find((o) => o.value === value)?.label ?? value;
}
interface BreakDraft {
key: string;
id: number;
collectionType: CollectionType;
playlistGroupId: number | null;
playlistId: number | null;
// preserved so non-playlist (legacy) break content round-trips intact
collectionId: number | null;
mediaItemId: number | null;
multiCollectionId: number | null;
smartCollectionId: number | null;
selectionName: string;
placement: BreakPlacement;
}
interface Draft {
name: string;
watermarkMode: DecoMode;
watermarkIds: number[];
useWatermarkDuringFiller: boolean;
graphicsElementsMode: DecoMode;
graphicsElementIds: number[];
useGraphicsElementsDuringFiller: boolean;
breakContentMode: DecoMode;
breakContent: BreakDraft[];
defaultFillerMode: DecoMode;
defaultFillerCollectionType: CollectionType;
defaultFillerId: number | null;
defaultFillerName: string;
defaultFillerTrimToFit: boolean;
deadAirFallbackMode: DecoMode;
deadAirFallbackCollectionType: CollectionType;
deadAirFallbackId: number | null;
deadAirFallbackName: string;
}
let keySeq = 0;
function nextKey(): string {
keySeq += 1;
return `break-${keySeq}`;
}
function firstUnusedPlacement(used: BreakPlacement[]): BreakPlacement {
return PLACEMENT_OPTIONS.find((o) => !used.includes(o.value))?.value ?? 'BlockStart';
}
function fillerIdFromResponse(
type: CollectionType,
collectionId: number | null | undefined,
mediaItemId: number | null | undefined,
multiCollectionId: number | null | undefined,
smartCollectionId: number | null | undefined
): number | null {
switch (type) {
case 'Collection':
return collectionId ?? null;
case 'MultiCollection':
return multiCollectionId ?? null;
case 'SmartCollection':
return smartCollectionId ?? null;
default:
return mediaItemId ?? null;
}
}
function draftFromResponse(deco: Deco): Draft {
return {
name: deco.name,
watermarkMode: deco.watermarkMode,
watermarkIds: deco.watermarkIds ?? [],
useWatermarkDuringFiller: deco.useWatermarkDuringFiller,
graphicsElementsMode: deco.graphicsElementsMode,
graphicsElementIds: deco.graphicsElementIds ?? [],
useGraphicsElementsDuringFiller: deco.useGraphicsElementsDuringFiller,
breakContentMode: deco.breakContentMode,
breakContent: (deco.breakContent ?? []).map((bc) => ({
key: nextKey(),
id: bc.id,
collectionType: bc.collectionType,
playlistGroupId: bc.playlistGroupId ?? null,
playlistId: bc.playlistId ?? null,
collectionId: bc.collectionId ?? null,
mediaItemId: bc.mediaItemId ?? null,
multiCollectionId: bc.multiCollectionId ?? null,
smartCollectionId: bc.smartCollectionId ?? null,
selectionName: bc.selectionName ?? '',
placement: bc.placement
})),
defaultFillerMode: deco.defaultFillerMode,
defaultFillerCollectionType: deco.defaultFillerCollectionType,
defaultFillerId: fillerIdFromResponse(
deco.defaultFillerCollectionType,
deco.defaultFillerCollectionId,
deco.defaultFillerMediaItemId,
deco.defaultFillerMultiCollectionId,
deco.defaultFillerSmartCollectionId
),
defaultFillerName: deco.defaultFillerSelectionName ?? '',
defaultFillerTrimToFit: deco.defaultFillerTrimToFit,
deadAirFallbackMode: deco.deadAirFallbackMode,
deadAirFallbackCollectionType: deco.deadAirFallbackCollectionType,
deadAirFallbackId: fillerIdFromResponse(
deco.deadAirFallbackCollectionType,
deco.deadAirFallbackCollectionId,
deco.deadAirFallbackMediaItemId,
deco.deadAirFallbackMultiCollectionId,
deco.deadAirFallbackSmartCollectionId
),
deadAirFallbackName: deco.deadAirFallbackSelectionName ?? ''
};
}
function fillerIdFields(type: CollectionType, id: number | null) {
return {
collectionId: type === 'Collection' ? id : null,
mediaItemId: type === 'TelevisionShow' || type === 'TelevisionSeason' || type === 'Artist' ? id : null,
multiCollectionId: type === 'MultiCollection' ? id : null,
smartCollectionId: type === 'SmartCollection' ? id : null
};
}
function breakToRequest(item: BreakDraft): DecoBreakContentRequest {
if (item.collectionType === 'Playlist') {
return {
id: item.id,
collectionType: 'Playlist',
collectionId: null,
mediaItemId: null,
multiCollectionId: null,
smartCollectionId: null,
playlistId: item.playlistId,
placement: item.placement
};
}
// preserve legacy (non-playlist) break content exactly as loaded
return {
id: item.id,
collectionType: item.collectionType,
collectionId: item.collectionId,
mediaItemId: item.mediaItemId,
multiCollectionId: item.multiCollectionId,
smartCollectionId: item.smartCollectionId,
playlistId: null,
placement: item.placement
};
}
function toReplaceRequest(draft: Draft): ReplaceDecoRequest {
const defaultFiller = fillerIdFields(draft.defaultFillerCollectionType, draft.defaultFillerId);
const deadAir = fillerIdFields(draft.deadAirFallbackCollectionType, draft.deadAirFallbackId);
return {
name: draft.name.trim(),
watermarkMode: draft.watermarkMode,
watermarkIds: draft.watermarkIds,
useWatermarkDuringFiller: draft.useWatermarkDuringFiller,
graphicsElementsMode: draft.graphicsElementsMode,
graphicsElementIds: draft.graphicsElementIds,
useGraphicsElementsDuringFiller: draft.useGraphicsElementsDuringFiller,
breakContentMode: draft.breakContentMode,
breakContent: draft.breakContent.map(breakToRequest),
defaultFillerMode: draft.defaultFillerMode,
defaultFillerCollectionType: draft.defaultFillerCollectionType,
defaultFillerCollectionId: defaultFiller.collectionId,
defaultFillerMediaItemId: defaultFiller.mediaItemId,
defaultFillerMultiCollectionId: defaultFiller.multiCollectionId,
defaultFillerSmartCollectionId: defaultFiller.smartCollectionId,
defaultFillerTrimToFit: draft.defaultFillerTrimToFit,
deadAirFallbackMode: draft.deadAirFallbackMode,
deadAirFallbackCollectionType: draft.deadAirFallbackCollectionType,
deadAirFallbackCollectionId: deadAir.collectionId,
deadAirFallbackMediaItemId: deadAir.mediaItemId,
deadAirFallbackMultiCollectionId: deadAir.multiCollectionId,
deadAirFallbackSmartCollectionId: deadAir.smartCollectionId
};
}
function validate(draft: Draft): null | string {
if (!draft.name.trim()) {
return 'Deco name is required';
}
if (draft.breakContentMode === 'Override') {
const placements = draft.breakContent.map((b) => b.placement);
if (placements.some((p, i) => placements.indexOf(p) !== i)) {
return 'Each break content placement may be used only once';
}
for (const b of draft.breakContent) {
if (b.collectionType === 'Playlist' && b.playlistId == null) {
return 'Every break content item needs a playlist';
}
}
}
if (draft.defaultFillerMode === 'Override' && draft.defaultFillerId == null) {
return 'Default filler needs a selection';
}
if (draft.deadAirFallbackMode === 'Override' && draft.deadAirFallbackId == null) {
return 'Dead air fallback needs a selection';
}
return null;
}
function searchFor(type: CollectionType): (query: string) => Promise<SchedulingPickerOption[]> {
switch (type) {
case 'Collection':
return searchCollections;
case 'MultiCollection':
return searchMultiCollections;
case 'SmartCollection':
return searchSmartCollections;
case 'TelevisionShow':
return searchTelevisionShows;
case 'TelevisionSeason':
return searchTelevisionSeasons;
case 'Artist':
return searchArtists;
default:
return async () => [];
}
}
type Mode = { id: number; kind: 'edit' } | { kind: 'list' };
function modeFromPath(pathname: string): Mode {
const normalized = pathname.replace(/\/+$/, '');
if (normalized === BASE_PATH || !normalized.startsWith(`${BASE_PATH}/`)) {
return { kind: 'list' };
}
const suffix = normalized.slice(BASE_PATH.length + 1).split('/')[0];
const id = Number(suffix);
return Number.isInteger(id) && id > 0 ? { id, kind: 'edit' } : { kind: 'list' };
}
export function DecosScreen() {
const [pathname, setPathname] = useState(() => window.location.pathname);
useEffect(() => {
const onPop = () => setPathname(window.location.pathname);
window.addEventListener('popstate', onPop);
return () => window.removeEventListener('popstate', onPop);
}, []);
const mode = modeFromPath(pathname);
if (mode.kind === 'list') {
return <DecoList key={pathname} />;
}
return <DecoEditor key={pathname} decoId={mode.id} />;
}
function DecoList() {
const [groups, setGroups] = useState<DecoGroup[] | null>(null);
const [decos, setDecos] = useState<DecoListItem[] | null>(null);
const [error, setError] = useState<null | string>(null);
const [groupDialogOpen, setGroupDialogOpen] = useState(false);
const [newGroupName, setNewGroupName] = useState('');
const [decoDialogGroup, setDecoDialogGroup] = useState<DecoGroup | null>(null);
const [newDecoName, setNewDecoName] = useState('');
const [deleteGroupTarget, setDeleteGroupTarget] = useState<DecoGroup | null>(null);
const [deleteDecoTarget, setDeleteDecoTarget] = useState<DecoListItem | null>(null);
const [busy, setBusy] = useState(false);
const activeRef = useRef(true);
const load = useCallback(() => {
Promise.all([getDecoGroups(), getDecos()])
.then(([groupData, decoData]) => {
if (activeRef.current) {
setGroups(groupData);
setDecos(decoData);
setError(null);
}
})
.catch((loadError: unknown) => {
if (activeRef.current) {
setError(messageFromDecoError(loadError));
}
});
}, []);
useEffect(() => {
activeRef.current = true;
load();
return () => {
activeRef.current = false;
};
}, [load]);
const createGroup = async () => {
if (!newGroupName.trim() || busy) {
return;
}
setBusy(true);
try {
await createDecoGroup({ name: newGroupName.trim() });
setGroupDialogOpen(false);
setNewGroupName('');
load();
} catch (createError) {
setError(messageFromDecoError(createError, 'Unable to create deco group'));
} finally {
setBusy(false);
}
};
const createDecoInGroup = async () => {
if (!decoDialogGroup || !newDecoName.trim() || busy) {
return;
}
setBusy(true);
try {
const deco = await createDeco({ decoGroupId: decoDialogGroup.id, name: newDecoName.trim() });
setDecoDialogGroup(null);
setNewDecoName('');
navigateToPath(`${BASE_PATH}/${deco.id}`);
} catch (createError) {
setError(messageFromDecoError(createError, 'Unable to create deco'));
} finally {
setBusy(false);
}
};
const confirmDeleteGroup = async () => {
if (!deleteGroupTarget) {
return;
}
setBusy(true);
try {
await deleteDecoGroup(deleteGroupTarget.id);
setDeleteGroupTarget(null);
load();
} catch (deleteError) {
setError(messageFromDecoError(deleteError, 'Unable to delete deco group'));
} finally {
setBusy(false);
}
};
const confirmDeleteDeco = async () => {
if (!deleteDecoTarget) {
return;
}
setBusy(true);
try {
await deleteDeco(deleteDecoTarget.id);
setDeleteDecoTarget(null);
load();
} catch (deleteError) {
setError(messageFromDecoError(deleteError, 'Unable to delete deco'));
} finally {
setBusy(false);
}
};
if (error && (!groups || !decos)) {
return (
<div className="ctv-collections">
<div className="ctv-channels-error" role="alert">
<TriangleAlert aria-hidden="true" size={15} />
<span>{error}</span>
<span className="ctv-channels-spacer" />
<Button onClick={load} size="sm" variant="secondary">
Retry
</Button>
</div>
</div>
);
}
if (!groups || !decos) {
return (
<div className="ctv-collections-loading" role="status">
<Spinner size={18} />
<span>Loading decos…</span>
</div>
);
}
const sortedGroups = [...groups].sort((a, b) => a.name.localeCompare(b.name));
return (
<div className="ctv-collections">
<div className="ctv-channels-actionbar">
<Badge tone="neutral">{decos.length} decos</Badge>
<span className="ctv-channels-spacer" />
<Button
onClick={() => {
setNewGroupName('');
setGroupDialogOpen(true);
}}
size="sm"
startIcon={<FolderPlus aria-hidden="true" size={14} />}
>
New group
</Button>
</div>
{error && (
<div className="ctv-channels-error" role="alert">
<TriangleAlert aria-hidden="true" size={15} />
<span>{error}</span>
</div>
)}
{sortedGroups.length === 0 ? (
<Card>
<div className="ctv-collections-empty">No deco groups yet. Create one to get started.</div>
</Card>
) : (
sortedGroups.map((group) => {
const groupDecos = decos
.filter((d) => d.decoGroupId === group.id)
.sort((a, b) => a.name.localeCompare(b.name));
return (
<Card
key={group.id}
padded={false}
title={group.name}
actions={
<div style={{ display: 'flex', gap: 8 }}>
<Button
onClick={() => {
setNewDecoName('');
setDecoDialogGroup(group);
}}
size="sm"
startIcon={<Plus aria-hidden="true" size={14} />}
variant="secondary"
>
New deco
</Button>
<IconButton
onClick={() => setDeleteGroupTarget(group)}
size="sm"
title="Delete group"
variant="ghost"
>
<Trash2 aria-hidden="true" size={14} />
</IconButton>
</div>
}
>
{groupDecos.length === 0 ? (
<div className="ctv-collections-empty">No decos in this group.</div>
) : (
groupDecos.map((deco, index) => (
<div
className="ctv-settings-flush-row"
key={deco.id}
style={index === 0 ? { borderTop: 'none' } : undefined}
>
<Palette aria-hidden="true" color="var(--ctv-accent)" size={15} />
<button
className="ctv-settings-flush-row-main ctv-settings-flush-row-title ctv-collections-linkbtn"
onClick={() => navigateToPath(`${BASE_PATH}/${deco.id}`)}
type="button"
>
{deco.name}
</button>
<IconButton
onClick={() => setDeleteDecoTarget(deco)}
size="sm"
title="Delete deco"
variant="ghost"
>
<Trash2 aria-hidden="true" size={14} />
</IconButton>
</div>
))
)}
</Card>
);
})
)}
<Dialog
footer={
<>
<Button onClick={() => setGroupDialogOpen(false)} size="sm" variant="ghost">
Cancel
</Button>
<Button disabled={!newGroupName.trim() || busy} loading={busy} onClick={() => void createGroup()} size="sm">
Create
</Button>
</>
}
onClose={() => setGroupDialogOpen(false)}
open={groupDialogOpen}
title="New deco group"
>
<Input
label="Name"
onChange={(event) => setNewGroupName(event.target.value)}
placeholder="Deco group name"
value={newGroupName}
/>
</Dialog>
<Dialog
footer={
<>
<Button onClick={() => setDecoDialogGroup(null)} size="sm" variant="ghost">
Cancel
</Button>
<Button
disabled={!newDecoName.trim() || busy}
loading={busy}
onClick={() => void createDecoInGroup()}
size="sm"
>
Create
</Button>
</>
}
onClose={() => setDecoDialogGroup(null)}
open={decoDialogGroup !== null}
title={decoDialogGroup ? `New deco in ${decoDialogGroup.name}` : 'New deco'}
>
<Input
label="Name"
onChange={(event) => setNewDecoName(event.target.value)}
placeholder="Deco name"
value={newDecoName}
/>
</Dialog>
<ConfirmDialog
busy={busy}
confirmLabel="Delete"
message={
deleteGroupTarget
? `Delete group "${deleteGroupTarget.name}"? Every deco in it will also be deleted. This cannot be undone.`
: ''
}
onCancel={() => setDeleteGroupTarget(null)}
onConfirm={() => void confirmDeleteGroup()}
open={deleteGroupTarget !== null}
title="Delete deco group"
tone="danger"
/>
<ConfirmDialog
busy={busy}
confirmLabel="Delete"
message={deleteDecoTarget ? `Delete deco "${deleteDecoTarget.name}"? This cannot be undone.` : ''}
onCancel={() => setDeleteDecoTarget(null)}
onConfirm={() => void confirmDeleteDeco()}
open={deleteDecoTarget !== null}
title="Delete deco"
tone="danger"
/>
</div>
);
}
function Row({
children,
control = 360,
first = false,
label
}: {
children: ReactNode;
control?: number;
first?: boolean;
label: string;
}) {
return (
<div className="ctv-settings-row" style={first ? { borderTop: 'none' } : undefined}>
<div className="ctv-settings-row-main">
<div className="ctv-settings-row-label">{label}</div>
</div>
<div className="ctv-settings-row-control" style={{ flex: `0 0 ${control}px` }}>
{children}
</div>
</div>
);
}
function AsyncPicker({
currentName,
onSelect,
search
}: {
currentName: string;
onSelect: (option: SchedulingPickerOption) => void;
search: (query: string) => Promise<SchedulingPickerOption[]>;
}) {
const [query, setQuery] = useState('');
const [options, setOptions] = useState<SchedulingPickerOption[]>([]);
const seqRef = useRef(0);
const activeRef = useRef(true);
useEffect(() => {
activeRef.current = true;
return () => {
activeRef.current = false;
};
}, []);
useEffect(() => {
const trimmed = query.trim();
if (!trimmed) {
return;
}
const seq = seqRef.current + 1;
seqRef.current = seq;
const handle = window.setTimeout(() => {
search(trimmed)
.then((results) => {
if (activeRef.current && seqRef.current === seq) {
setOptions(results);
}
})
.catch(() => {
if (activeRef.current && seqRef.current === seq) {
setOptions([]);
}
});
}, 280);
return () => window.clearTimeout(handle);
}, [query, search]);
return (
<div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
{currentName && <Badge tone="accent">{currentName}</Badge>}
<Input onChange={(event) => setQuery(event.target.value)} placeholder="Type to search…" size="sm" value={query} />
{query.trim() !== '' && options.length > 0 && (
<Card padded={false}>
{options.map((option) => (
<button
className="ctv-settings-flush-row ctv-collections-linkbtn"
key={option.id}
onClick={() => {
onSelect(option);
setQuery('');
setOptions([]);
}}
style={{ textAlign: 'left', width: '100%' }}
type="button"
>
{option.name}
</button>
))}
</Card>
)}
</div>
);
}
function MultiSelect({
disabled = false,
onToggle,
options,
selected
}: {
disabled?: boolean;
onToggle: (id: number) => void;
options: Array<{ id: number; name: null | string }>;
selected: number[];
}) {
if (options.length === 0) {
return <span className="ctv-settings-row-help">None available.</span>;
}
return (
<div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
{options.map((option) => (
<Checkbox
checked={selected.includes(option.id)}
disabled={disabled}
key={option.id}
label={option.name ?? `#${option.id}`}
onChange={() => onToggle(option.id)}
/>
))}
</div>
);
}
function PlaylistPicker({
groups,
onChange,
playlistGroupId,
playlistId
}: {
groups: PlaylistGroup[];
onChange: (patch: { playlistGroupId: number | null; playlistId: number | null }) => void;
playlistGroupId: number | null;
playlistId: number | null;
}) {
const [playlists, setPlaylists] = useState<Playlist[]>([]);
useEffect(() => {
if (playlistGroupId == null) {
// Nothing to fetch; the render derives the options for the current group, so
// stale playlists from a previous group stay hidden without a sync setState here.
return;
}
let active = true;
getPlaylists(playlistGroupId)
.then((data) => {
if (active) {
setPlaylists(data);
}
})
.catch(() => {
if (active) {
setPlaylists([]);
}
});
return () => {
active = false;
};
}, [playlistGroupId]);
// Only playlists belonging to the currently-selected group are valid options.
const groupPlaylists = playlistGroupId == null ? [] : playlists.filter((p) => p.playlistGroupId === playlistGroupId);
return (
<>
<Row control={360} label="Playlist group">
<Select
onChange={(event) => {
const value = event.target.value === '' ? null : Number(event.target.value);
onChange({ playlistGroupId: value, playlistId: null });
}}
options={[
{ label: '(choose a group)', value: '' },
...groups.map((g) => ({ label: g.name, value: String(g.id) }))
]}
value={playlistGroupId == null ? '' : String(playlistGroupId)}
/>
</Row>
<Row control={360} label="Playlist">
<Select
disabled={playlistGroupId == null}
onChange={(event) => {
const value = event.target.value === '' ? null : Number(event.target.value);
onChange({ playlistGroupId, playlistId: value });
}}
options={[
{ label: '(choose a playlist)', value: '' },
...groupPlaylists.map((p) => ({ label: p.name, value: String(p.id) }))
]}
value={playlistId == null ? '' : String(playlistId)}
/>
</Row>
</>
);
}
function DecoEditor({ decoId }: { decoId: number }) {
const [deco, setDeco] = useState<Deco | null>(null);
const [draft, setDraft] = useState<Draft | null>(null);
const [selectedBreakKey, setSelectedBreakKey] = useState<null | string>(null);
const [watermarks, setWatermarks] = useState<Watermark[]>([]);
const [graphicsElements, setGraphicsElements] = useState<GraphicsElement[]>([]);
const [playlistGroups, setPlaylistGroups] = useState<PlaylistGroup[]>([]);
const [loadError, setLoadError] = useState<null | string>(null);
const [saveError, setSaveError] = useState<null | string>(null);
const [saving, setSaving] = useState(false);
useEffect(() => {
let active = true;
Promise.all([getDeco(decoId), getWatermarks(), getGraphicsElements(), getPlaylistGroups()])
.then(([decoData, watermarkData, graphicsData, playlistGroupData]) => {
if (!active) {
return;
}
setDeco(decoData);
setWatermarks(watermarkData);
setGraphicsElements(graphicsData);
setPlaylistGroups(playlistGroupData);
setDraft(draftFromResponse(decoData));
})
.catch((error: unknown) => {
if (active) {
setLoadError(messageFromDecoError(error, 'Unable to load deco'));
}
});
return () => {
active = false;
};
}, [decoId]);
if (loadError) {
return (
<div className="ctv-settings-error" role="alert">
<TriangleAlert aria-hidden="true" size={16} />
<span>{loadError}</span>
<Button onClick={() => navigateToPath(BASE_PATH)} size="sm" variant="secondary">
Back to decos
</Button>
</div>
);
}
if (!draft || !deco) {
return (
<div className="ctv-settings-loading">
<Spinner size={18} />
<span>Loading deco…</span>
</div>
);
}
const setDraftValue = (patch: Partial<Draft>) => {
setDraft((current) => (current ? { ...current, ...patch } : current));
};
const updateBreak = (key: string, patch: Partial<BreakDraft>) => {
setDraft((current) =>
current
? { ...current, breakContent: current.breakContent.map((b) => (b.key === key ? { ...b, ...patch } : b)) }
: current
);
};
const addBreak = () => {
const used = draft.breakContent.map((b) => b.placement);
const item: BreakDraft = {
key: nextKey(),
id: 0,
collectionType: 'Playlist',
playlistGroupId: null,
playlistId: null,
collectionId: null,
mediaItemId: null,
multiCollectionId: null,
smartCollectionId: null,
selectionName: '',
placement: firstUnusedPlacement(used)
};
setDraft((current) => (current ? { ...current, breakContent: [...current.breakContent, item] } : current));
setSelectedBreakKey(item.key);
};
const removeBreak = (key: string) => {
setDraft((current) =>
current ? { ...current, breakContent: current.breakContent.filter((b) => b.key !== key) } : current
);
if (selectedBreakKey === key) {
setSelectedBreakKey(null);
}
};
const validationError = validate(draft);
const save = async () => {
if (validationError || saving) {
return;
}
setSaving(true);
setSaveError(null);
try {
await replaceDeco(decoId, toReplaceRequest(draft));
navigateToPath(BASE_PATH);
} catch (error) {
setSaveError(messageFromDecoError(error, 'Unable to save deco'));
} finally {
setSaving(false);
}
};
const watermarkActive = draft.watermarkMode === 'Override' || draft.watermarkMode === 'Merge';
const graphicsActive = draft.graphicsElementsMode === 'Override' || draft.graphicsElementsMode === 'Merge';
const selectedBreak = draft.breakContent.find((b) => b.key === selectedBreakKey) ?? null;
return (
<div className="ctv-collections">
<div className="ctv-channels-actionbar">
<Button
onClick={() => navigateToPath(BASE_PATH)}
size="sm"
startIcon={<ArrowLeft aria-hidden="true" size={14} />}
variant="ghost"
>
All decos
</Button>
<span className="ctv-collections-detail-title">{deco.decoGroupName} / Edit deco</span>
<span className="ctv-channels-spacer" />
{saveError && <span className="ctv-settings-savebar-error">{saveError}</span>}
{validationError && <Badge tone="neutral">{validationError}</Badge>}
<Button
disabled={validationError !== null || saving}
loading={saving}
onClick={() => void save()}
size="sm"
startIcon={<Check aria-hidden="true" size={14} />}
>
Save deco
</Button>
</div>
<Card padded={false} title="Deco">
<Row control={360} first label="Deco group">
<Input disabled size="sm" value={deco.decoGroupName} />
</Row>
<Row control={360} label="Deco name">
<Input
error={draft.name.trim() ? null : 'Deco name is required'}
onChange={(event) => setDraftValue({ name: event.target.value })}
size="sm"
value={draft.name}
/>
</Row>
</Card>
<Card padded={false} title="Watermark">
<Row control={360} first label="Watermark mode">
<Select
onChange={(event) => setDraftValue({ watermarkMode: event.target.value as DecoMode })}
options={WATERMARK_MODE_OPTIONS}
value={draft.watermarkMode}
/>
</Row>
<Row control={360} label="Watermarks">
<MultiSelect
disabled={!watermarkActive}
onToggle={(id) =>
setDraftValue({
watermarkIds: draft.watermarkIds.includes(id)
? draft.watermarkIds.filter((w) => w !== id)
: [...draft.watermarkIds, id]
})
}
options={watermarks}
selected={draft.watermarkIds}
/>
</Row>
<Row control={360} label="Use watermark during filler">
<Checkbox
checked={draft.useWatermarkDuringFiller}
disabled={draft.watermarkMode !== 'Override'}
onChange={(useWatermarkDuringFiller) => setDraftValue({ useWatermarkDuringFiller })}
/>
</Row>
</Card>
<Card padded={false} title="Graphics elements">
<Row control={360} first label="Graphics elements mode">
<Select
onChange={(event) => setDraftValue({ graphicsElementsMode: event.target.value as DecoMode })}
options={WATERMARK_MODE_OPTIONS}
value={draft.graphicsElementsMode}
/>
</Row>
<Row control={360} label="Graphics elements">
<MultiSelect
disabled={!graphicsActive}
onToggle={(id) =>
setDraftValue({
graphicsElementIds: draft.graphicsElementIds.includes(id)
? draft.graphicsElementIds.filter((g) => g !== id)
: [...draft.graphicsElementIds, id]
})
}
options={graphicsElements}
selected={draft.graphicsElementIds}
/>
</Row>
<Row control={360} label="Use graphics elements during filler">
<Checkbox
checked={draft.useGraphicsElementsDuringFiller}
disabled={draft.graphicsElementsMode !== 'Override'}
onChange={(useGraphicsElementsDuringFiller) => setDraftValue({ useGraphicsElementsDuringFiller })}
/>
</Row>
</Card>
<Card
actions={
draft.breakContentMode === 'Override' ? (
<Button onClick={addBreak} size="sm" startIcon={<Plus aria-hidden="true" size={14} />} variant="secondary">
Add break content
</Button>
) : undefined
}
padded={false}
title="Break content"
>
<Row control={360} first label="Break content mode">
<Select
onChange={(event) => setDraftValue({ breakContentMode: event.target.value as DecoMode })}
options={BASIC_MODE_OPTIONS}
value={draft.breakContentMode}
/>
</Row>
{draft.breakContentMode === 'Override' &&
(draft.breakContent.length === 0 ? (
<div className="ctv-collections-empty">No break content yet. Add one to play items during breaks.</div>
) : (
<table className="ctv-channels-table">
<thead>
<tr>
<th>Placement</th>
<th>Type</th>
<th>Name</th>
<th />
</tr>
</thead>
<tbody>
{draft.breakContent.map((item) => (
<tr
key={item.key}
onClick={() => setSelectedBreakKey(item.key)}
style={{
cursor: 'pointer',
background:
item.key === selectedBreakKey ? 'var(--ctv-surface-hover, rgba(255,255,255,0.04))' : undefined
}}
>
<td>{placementLabel(item.placement)}</td>
<td>{item.collectionType}</td>
<td>{item.selectionName || '(none)'}</td>
<td onClick={(event) => event.stopPropagation()}>
<IconButton onClick={() => removeBreak(item.key)} size="sm" title="Remove" variant="ghost">
<Trash2 aria-hidden="true" size={14} />
</IconButton>
</td>
</tr>
))}
</tbody>
</table>
))}
</Card>
{draft.breakContentMode === 'Override' && selectedBreak && (
<Card padded={false} title="Break content item">
<Row control={360} first label="Placement">
<Select
onChange={(event) => updateBreak(selectedBreak.key, { placement: event.target.value as BreakPlacement })}
options={PLACEMENT_OPTIONS.filter(
(o) =>
o.value === selectedBreak.placement ||
!draft.breakContent.some((b) => b.key !== selectedBreak.key && b.placement === o.value)
)}
value={selectedBreak.placement}
/>
</Row>
{selectedBreak.collectionType === 'Playlist' ? (
<PlaylistPicker
groups={playlistGroups}
onChange={(patch) => updateBreak(selectedBreak.key, patch)}
playlistGroupId={selectedBreak.playlistGroupId}
playlistId={selectedBreak.playlistId}
/>
) : (
<Row control={360} label="Selection">
<Badge tone="accent">{selectedBreak.selectionName || '(none)'}</Badge>
</Row>
)}
</Card>
)}
<Card padded={false} title="Default filler">
<Row control={360} first label="Default filler mode">
<Select
onChange={(event) => setDraftValue({ defaultFillerMode: event.target.value as DecoMode })}
options={BASIC_MODE_OPTIONS}
value={draft.defaultFillerMode}
/>
</Row>
{draft.defaultFillerMode === 'Override' && (
<>
<Row control={360} label="Collection type">
<Select
onChange={(event) =>
setDraftValue({
defaultFillerCollectionType: event.target.value as CollectionType,
defaultFillerId: null,
defaultFillerName: ''
})
}
options={FILLER_TYPE_OPTIONS}
value={draft.defaultFillerCollectionType}
/>
</Row>
<Row control={360} label={fillerTypeLabel(draft.defaultFillerCollectionType)}>
<AsyncPicker
currentName={draft.defaultFillerName}
key={`default-${draft.defaultFillerCollectionType}`}
onSelect={(option) =>
setDraftValue({ defaultFillerId: option.id, defaultFillerName: option.name })
}
search={searchFor(draft.defaultFillerCollectionType)}
/>
</Row>
<Row control={360} label="Trim to fit">
<Checkbox
checked={draft.defaultFillerTrimToFit}
onChange={(defaultFillerTrimToFit) => setDraftValue({ defaultFillerTrimToFit })}
/>
</Row>
</>
)}
</Card>
<Card padded={false} title="Dead air fallback">
<Row control={360} first label="Dead air fallback mode">
<Select
onChange={(event) => setDraftValue({ deadAirFallbackMode: event.target.value as DecoMode })}
options={BASIC_MODE_OPTIONS}
value={draft.deadAirFallbackMode}
/>
</Row>
{draft.deadAirFallbackMode === 'Override' && (
<>
<Row control={360} label="Collection type">
<Select
onChange={(event) =>
setDraftValue({
deadAirFallbackCollectionType: event.target.value as CollectionType,
deadAirFallbackId: null,
deadAirFallbackName: ''
})
}
options={FILLER_TYPE_OPTIONS}
value={draft.deadAirFallbackCollectionType}
/>
</Row>
<Row control={360} label={fillerTypeLabel(draft.deadAirFallbackCollectionType)}>
<AsyncPicker
currentName={draft.deadAirFallbackName}
key={`deadair-${draft.deadAirFallbackCollectionType}`}
onSelect={(option) =>
setDraftValue({ deadAirFallbackId: option.id, deadAirFallbackName: option.name })
}
search={searchFor(draft.deadAirFallbackCollectionType)}
/>
</Row>
</>
)}
</Card>
</div>
);
}