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>
1232 lines
40 KiB
TypeScript
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>
|
|
);
|
|
}
|