Build ErsatzTV Image / decisions.md append-only (pull_request) Successful in 10s
Build ErsatzTV Image / Docs update reminder (pull_request) Successful in 10s
Build ErsatzTV Image / Formatting (changed .cs conform to .editorconfig) (pull_request) Successful in 1m12s
Build ErsatzTV Image / API docs in sync (OpenAPI + endpoint index) (pull_request) Successful in 3m4s
Build ErsatzTV Image / Build & test (.NET) (pull_request) Successful in 8m17s
Build ErsatzTV Image / EF migration integrity (SQLite + MySql) (pull_request) Successful in 10m36s
Build ErsatzTV Image / Build & push image (amd64) (pull_request) Has been skipped
Version every /api route to /api/v1 (251 controller routes + ~24 Location
headers + the scanner callback URL + the Startup request-log literal),
uniform across the machine API, auth, scanner and scripted-build surfaces.
Add ApiVersionRewriteMiddleware: a legacy unversioned /api/* request is
rewritten (NOT redirected) to /api/v1/* in-pipeline — method, body, auth
headers and query survive — carrying RFC 8594 Deprecation/Sunset headers,
so curl / the future MCP server / bookmarks keep working. An already-
versioned path passes through; a future /api/v2 is never forced to v1.
Standardize the route convention (leading-slash absolute route per method,
no class-[Route] — except the two Scanner/Scripted controllers whose ~all
actions share a parametrized {id} prefix), enforced by ApiRouteVersioningTests
(^/api/v\d+/ over the whole Controllers.Api surface; browser-nav
/auth/oidc/login is out of scope).
Regenerate v1.json (160 paths, all /api/v1)/endpoint-index/v1.d.ts; sweep 945
SPA request literals + the test mocks (regex + positional URL parsers). /api/v1
is additive-only after freeze; the legacy-rewrite shim sunsets in ~2 releases
(owner decision) with removal tracked as a Phase-3 follow-up.
Docs: decisions.md 2026-07-13, api-conventions §1/§9, rest-api/spa-conventions/
blazor-route-parity/e2e-local/domain-model.
fixes #286
refs #197
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
472 lines
16 KiB
TypeScript
472 lines
16 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from 'react';
|
|
import { ApiError, request, requestWithMeta, type ResponseWithMeta } from './client';
|
|
import type { components } from './generated/v1';
|
|
|
|
export type PlayoutSummary = components['schemas']['PlayoutListItemResponseModel'];
|
|
export type PlayoutDetail = components['schemas']['PlayoutResponseModel'];
|
|
export type PlayoutItem = components['schemas']['PlayoutItemResponseModel'];
|
|
export type PlayoutsPage = components['schemas']['PagedPlayoutsResponseModel'];
|
|
export type PlayoutItemsPage = components['schemas']['PagedPlayoutItemsResponseModel'];
|
|
export type PlayoutChannelState = components['schemas']['ChannelStateResponseModel'];
|
|
export type PlayoutScheduleKind = components['schemas']['PlayoutScheduleKind'];
|
|
export type ChannelPlayoutMode = components['schemas']['ChannelPlayoutMode'];
|
|
export type PlayoutItemSchedulingContext = components['schemas']['PlayoutItemSchedulingContextResponseModel'];
|
|
export type CreatePlayoutRequest = components['schemas']['CreatePlayoutRequest'];
|
|
export type UpdatePlayoutDetailsRequest = components['schemas']['UpdatePlayoutDetailsRequest'];
|
|
|
|
// DayOfWeek is a day-name string on the wire ("Sunday" … "Saturday"). As of #287 the OpenAPI
|
|
// schema emits it as a string enum (added to Startup.UseStringEnumSchemas), so the generated
|
|
// `daysOfWeek` shape is already correct and no override is needed — the DTO aliases below point
|
|
// straight at the generated schemas. This local union is kept for the DAYS_OF_WEEK ordering
|
|
// constant and equals components['schemas']['DayOfWeek'].
|
|
export type DayOfWeek =
|
|
| 'Sunday'
|
|
| 'Monday'
|
|
| 'Tuesday'
|
|
| 'Wednesday'
|
|
| 'Thursday'
|
|
| 'Friday'
|
|
| 'Saturday';
|
|
|
|
// Monday-first, matching the Blazor editor's ordering.
|
|
export const DAYS_OF_WEEK: DayOfWeek[] = [
|
|
'Monday',
|
|
'Tuesday',
|
|
'Wednesday',
|
|
'Thursday',
|
|
'Friday',
|
|
'Saturday',
|
|
'Sunday'
|
|
];
|
|
|
|
export type PlayoutAlternateSchedule = components['schemas']['PlayoutAlternateScheduleResponseModel'];
|
|
export type PlayoutAlternateScheduleItemRequest = components['schemas']['PlayoutAlternateScheduleItemRequest'];
|
|
export type PlayoutTemplate = components['schemas']['PlayoutTemplateResponseModel'];
|
|
export type PlayoutTemplateItemRequest = components['schemas']['PlayoutTemplateItemRequest'];
|
|
|
|
// Declared as `type` (not `interface`) so they satisfy the client's `Record<string, unknown>`
|
|
// RequestBody bound, matching the generated request DTOs.
|
|
export type ReplacePlayoutAlternateSchedulesRequest = {
|
|
items: PlayoutAlternateScheduleItemRequest[];
|
|
};
|
|
|
|
export type ReplacePlayoutTemplatesRequest = {
|
|
items: PlayoutTemplateItemRequest[];
|
|
};
|
|
|
|
export interface PlayoutsScreenData {
|
|
channelStates: PlayoutChannelState[];
|
|
items: PlayoutItem[];
|
|
playout: PlayoutDetail | null;
|
|
playouts: PlayoutSummary[];
|
|
selectedPlayoutId: number | null;
|
|
totalCount: number;
|
|
warningsCount: number;
|
|
}
|
|
|
|
type PlayoutsScreenBase = Omit<PlayoutsScreenData, 'items' | 'playout'>;
|
|
|
|
export type PlayoutsScreenQueryState =
|
|
| {
|
|
data: PlayoutsScreenData;
|
|
error: null;
|
|
itemsLoading: boolean;
|
|
refresh: () => void;
|
|
setActivePlayout: (playoutId: number) => void;
|
|
setShowFiller: (showFiller: boolean) => void;
|
|
showFiller: boolean;
|
|
status: 'success';
|
|
}
|
|
| { data: null; error: string; refresh: () => void; status: 'error' }
|
|
| { data: null; error: null; refresh: () => void; status: 'loading' };
|
|
|
|
type PlayoutsScreenState =
|
|
| { data: PlayoutsScreenData; error: null; itemsLoading: boolean; status: 'success' }
|
|
| { data: null; error: string; status: 'error' }
|
|
| { data: null; error: null; status: 'loading' };
|
|
|
|
export function getPlayouts(): Promise<PlayoutsPage> {
|
|
return request<PlayoutsPage>('/api/v1/playouts');
|
|
}
|
|
|
|
export function getPlayout(playoutId: number): Promise<PlayoutDetail> {
|
|
return request<PlayoutDetail>(`/api/v1/playouts/${playoutId}`);
|
|
}
|
|
|
|
export function getPlayoutItems(playoutId: number, showFiller = false): Promise<PlayoutItemsPage> {
|
|
return request<PlayoutItemsPage>(`/api/v1/playouts/${playoutId}/items${showFiller ? '?showFiller=true' : ''}`);
|
|
}
|
|
|
|
export function getPlayoutWarningsCount(): Promise<number> {
|
|
return request<number>('/api/v1/playouts/warnings/count');
|
|
}
|
|
|
|
export function getPlayoutChannelStates(): Promise<PlayoutChannelState[]> {
|
|
return request<PlayoutChannelState[]>('/api/v1/channels/state');
|
|
}
|
|
|
|
export type ResetAllPlayoutsResult = components['schemas']['ResetAllPlayoutsResponseModel'];
|
|
|
|
// Queues a reset of every eligible playout. Returns 202 with a body reporting which playouts were
|
|
// queued vs skipped (locked, or an unsupported ExternalJson/None schedule kind) — #235 replaced the
|
|
// old silent skip. The caller may surface `skipped*` to explain why some playouts didn't reset.
|
|
export function resetAllPlayouts(): Promise<ResetAllPlayoutsResult> {
|
|
return request<ResetAllPlayoutsResult>('/api/v1/playouts/reset-all', { method: 'POST' });
|
|
}
|
|
|
|
export function deletePlayout(playoutId: number): Promise<void> {
|
|
return request<void>(`/api/v1/playouts/${playoutId}`, { method: 'DELETE' });
|
|
}
|
|
|
|
// Resets the given channel's playout. The server picks the correct default mode per schedule kind
|
|
// (Classic → Refresh, others → Reset), matching the Blazor "Reset Playout" action — so no mode is sent.
|
|
// Keyed on the immutable channel id (not the user-mutable number), matching the /api/v1/channels/{id} contract.
|
|
export function resetChannelPlayout(channelId: number): Promise<void> {
|
|
return request<void>(`/api/v1/channels/${channelId}/playout/reset`, { method: 'POST' });
|
|
}
|
|
|
|
export function erasePlayoutItems(playoutId: number): Promise<void> {
|
|
return request<void>(`/api/v1/playouts/${playoutId}/erase-items`, { method: 'POST' });
|
|
}
|
|
|
|
export function erasePlayoutItemsAndHistory(playoutId: number): Promise<void> {
|
|
return request<void>(`/api/v1/playouts/${playoutId}/erase-items-and-history`, { method: 'POST' });
|
|
}
|
|
|
|
export function getPlayoutItemSchedulingContext(itemId: number): Promise<PlayoutItemSchedulingContext> {
|
|
return request<PlayoutItemSchedulingContext>(`/api/v1/playouts/items/${itemId}/scheduling-context`);
|
|
}
|
|
|
|
export function createPlayout(body: CreatePlayoutRequest): Promise<PlayoutDetail> {
|
|
return request<PlayoutDetail>('/api/v1/playouts', {
|
|
body,
|
|
method: 'POST'
|
|
});
|
|
}
|
|
|
|
export function updatePlayoutDetails(playoutId: number, body: UpdatePlayoutDetailsRequest): Promise<PlayoutDetail> {
|
|
return request<PlayoutDetail>(`/api/v1/playouts/${playoutId}`, {
|
|
body,
|
|
method: 'PUT'
|
|
});
|
|
}
|
|
|
|
export function updatePlayoutDefaultDeco(playoutId: number, decoId: number | null): Promise<PlayoutDetail> {
|
|
return request<PlayoutDetail>(`/api/v1/playouts/${playoutId}/deco`, {
|
|
body: { decoId },
|
|
method: 'PUT'
|
|
});
|
|
}
|
|
|
|
export function getAlternateSchedules(playoutId: number): Promise<PlayoutAlternateSchedule[]> {
|
|
return request<PlayoutAlternateSchedule[]>(`/api/v1/playouts/${playoutId}/alternate-schedules`);
|
|
}
|
|
|
|
/** Load alternate schedules together with the playout's concurrency ETag (issue #253). */
|
|
export function getAlternateSchedulesWithMeta(
|
|
playoutId: number
|
|
): Promise<ResponseWithMeta<PlayoutAlternateSchedule[]>> {
|
|
return requestWithMeta<PlayoutAlternateSchedule[]>(`/api/v1/playouts/${playoutId}/alternate-schedules`);
|
|
}
|
|
|
|
/**
|
|
* Replace a playout's alternate schedules. Pass the last-seen ETag as `If-Match` to reject a stale
|
|
* overwrite with 412; the resolved value carries the new ETag for a subsequent save (issue #253).
|
|
*/
|
|
export function replaceAlternateSchedules(
|
|
playoutId: number,
|
|
body: ReplacePlayoutAlternateSchedulesRequest,
|
|
ifMatch?: string | null
|
|
): Promise<ResponseWithMeta<PlayoutAlternateSchedule[]>> {
|
|
return requestWithMeta<PlayoutAlternateSchedule[]>(`/api/v1/playouts/${playoutId}/alternate-schedules`, {
|
|
body,
|
|
method: 'PUT',
|
|
headers: ifMatch ? { 'If-Match': ifMatch } : undefined
|
|
});
|
|
}
|
|
|
|
export function getPlayoutTemplates(playoutId: number): Promise<PlayoutTemplate[]> {
|
|
return request<PlayoutTemplate[]>(`/api/v1/playouts/${playoutId}/templates`);
|
|
}
|
|
|
|
/** Load playout templates together with the playout's concurrency ETag (issue #253). */
|
|
export function getPlayoutTemplatesWithMeta(playoutId: number): Promise<ResponseWithMeta<PlayoutTemplate[]>> {
|
|
return requestWithMeta<PlayoutTemplate[]>(`/api/v1/playouts/${playoutId}/templates`);
|
|
}
|
|
|
|
/**
|
|
* Replace a playout's templates. Pass the last-seen ETag as `If-Match` to reject a stale overwrite
|
|
* with 412; the resolved value carries the new ETag for a subsequent save (issue #253).
|
|
*/
|
|
export function replacePlayoutTemplates(
|
|
playoutId: number,
|
|
body: ReplacePlayoutTemplatesRequest,
|
|
ifMatch?: string | null
|
|
): Promise<ResponseWithMeta<PlayoutTemplate[]>> {
|
|
return requestWithMeta<PlayoutTemplate[]>(`/api/v1/playouts/${playoutId}/templates`, {
|
|
body,
|
|
method: 'PUT',
|
|
headers: ifMatch ? { 'If-Match': ifMatch } : undefined
|
|
});
|
|
}
|
|
|
|
export function messageFromPlayoutClientError(error: unknown, fallback = 'Unable to load playout'): string {
|
|
return messageFromPlayoutError(error, fallback);
|
|
}
|
|
|
|
export function usePlayoutsScreenQuery(pollMs = 30000): PlayoutsScreenQueryState {
|
|
const [state, setState] = useState<PlayoutsScreenState>({
|
|
data: null,
|
|
error: null,
|
|
status: 'loading'
|
|
});
|
|
const [showFiller, setShowFillerState] = useState(false);
|
|
const activeRef = useRef(true);
|
|
const selectedPlayoutIdRef = useRef<number | null>(null);
|
|
const showFillerRef = useRef(false);
|
|
// Snapshot of the last-known base fields (everything but the selected playout's
|
|
// detail/items), kept in sync whenever load()/loadChannelStates() succeed. Reading
|
|
// this lets setActivePlayout/setShowFiller kick off their fetch without doing the
|
|
// fetch from inside a setState updater (impure; StrictMode double-invokes updaters).
|
|
const baseRef = useRef<PlayoutsScreenBase>({
|
|
channelStates: [],
|
|
playouts: [],
|
|
selectedPlayoutId: null,
|
|
totalCount: 0,
|
|
warningsCount: 0
|
|
});
|
|
|
|
useEffect(() => {
|
|
activeRef.current = true;
|
|
|
|
return () => {
|
|
activeRef.current = false;
|
|
};
|
|
}, []);
|
|
|
|
const loadSelectedPlayout = useCallback((playoutId: number, base: PlayoutsScreenBase) => {
|
|
baseRef.current = base;
|
|
|
|
Promise.all([getPlayout(playoutId), getPlayoutItems(playoutId, showFillerRef.current)])
|
|
.then(([playout, itemsPage]) => {
|
|
if (!activeRef.current || selectedPlayoutIdRef.current !== playoutId) {
|
|
return;
|
|
}
|
|
|
|
setState((current) => {
|
|
// Merge onto whatever channel state the background poll may have landed
|
|
// while this request was in flight, rather than clobbering it with the
|
|
// snapshot captured when the request started.
|
|
const channelStates = current.status === 'success' ? current.data.channelStates : base.channelStates;
|
|
|
|
return {
|
|
data: {
|
|
...base,
|
|
channelStates,
|
|
items: itemsPage.page ?? [],
|
|
playout,
|
|
selectedPlayoutId: playoutId
|
|
},
|
|
error: null,
|
|
itemsLoading: false,
|
|
status: 'success'
|
|
};
|
|
});
|
|
})
|
|
.catch((error: unknown) => {
|
|
if (activeRef.current && selectedPlayoutIdRef.current === playoutId) {
|
|
setState({ data: null, error: messageFromPlayoutError(error), status: 'error' });
|
|
}
|
|
});
|
|
}, []);
|
|
|
|
const load = useCallback(() => {
|
|
Promise.all([getPlayouts(), getPlayoutWarningsCount(), getPlayoutChannelStates()])
|
|
.then(([playoutsPage, warningsCount, channelStates]) => {
|
|
if (!activeRef.current) {
|
|
return;
|
|
}
|
|
|
|
const playouts = playoutsPage.page ?? [];
|
|
const selectedPlayoutId = selectedPlayoutIdRef.current && playouts.some((playout) => playout.id === selectedPlayoutIdRef.current)
|
|
? selectedPlayoutIdRef.current
|
|
: playouts[0]?.id ?? null;
|
|
selectedPlayoutIdRef.current = selectedPlayoutId;
|
|
|
|
const base: PlayoutsScreenBase = {
|
|
channelStates,
|
|
playouts,
|
|
selectedPlayoutId,
|
|
totalCount: playoutsPage.totalCount,
|
|
warningsCount
|
|
};
|
|
baseRef.current = base;
|
|
|
|
if (selectedPlayoutId == null) {
|
|
setState({
|
|
data: {
|
|
...base,
|
|
items: [],
|
|
playout: null
|
|
},
|
|
error: null,
|
|
itemsLoading: false,
|
|
status: 'success'
|
|
});
|
|
return;
|
|
}
|
|
|
|
loadSelectedPlayout(selectedPlayoutId, base);
|
|
})
|
|
.catch((error: unknown) => {
|
|
if (activeRef.current) {
|
|
setState({ data: null, error: messageFromPlayoutError(error), status: 'error' });
|
|
}
|
|
});
|
|
}, [loadSelectedPlayout]);
|
|
|
|
const loadChannelStates = useCallback(() => {
|
|
getPlayoutChannelStates()
|
|
.then((channelStates) => {
|
|
if (!activeRef.current) {
|
|
return;
|
|
}
|
|
|
|
baseRef.current = { ...baseRef.current, channelStates };
|
|
|
|
setState((current) => {
|
|
if (current.status !== 'success') {
|
|
return current;
|
|
}
|
|
|
|
return {
|
|
data: { ...current.data, channelStates },
|
|
error: null,
|
|
itemsLoading: current.itemsLoading,
|
|
status: 'success'
|
|
};
|
|
});
|
|
})
|
|
.catch(() => {
|
|
// Keep the monitor visible on background polling failures.
|
|
});
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
load();
|
|
|
|
const intervalId = window.setInterval(loadChannelStates, pollMs);
|
|
|
|
return () => {
|
|
window.clearInterval(intervalId);
|
|
};
|
|
}, [load, loadChannelStates, pollMs]);
|
|
|
|
const refresh = useCallback(() => {
|
|
setState({ data: null, error: null, status: 'loading' });
|
|
load();
|
|
}, [load]);
|
|
|
|
const setActivePlayout = useCallback((playoutId: number) => {
|
|
selectedPlayoutIdRef.current = playoutId;
|
|
|
|
setState((current) => {
|
|
if (current.status !== 'success') {
|
|
return current;
|
|
}
|
|
|
|
return {
|
|
data: {
|
|
...current.data,
|
|
items: [],
|
|
playout: null,
|
|
selectedPlayoutId: playoutId
|
|
},
|
|
error: null,
|
|
itemsLoading: true,
|
|
status: 'success'
|
|
};
|
|
});
|
|
|
|
const base: PlayoutsScreenBase = { ...baseRef.current, selectedPlayoutId: playoutId };
|
|
loadSelectedPlayout(playoutId, base);
|
|
}, [loadSelectedPlayout]);
|
|
|
|
const setShowFiller = useCallback((next: boolean) => {
|
|
showFillerRef.current = next;
|
|
setShowFillerState(next);
|
|
|
|
const playoutId = selectedPlayoutIdRef.current;
|
|
|
|
if (playoutId == null) {
|
|
return;
|
|
}
|
|
|
|
setState((current) => {
|
|
if (current.status !== 'success') {
|
|
return current;
|
|
}
|
|
|
|
return { ...current, itemsLoading: true };
|
|
});
|
|
|
|
getPlayoutItems(playoutId, next)
|
|
.then((itemsPage) => {
|
|
if (!activeRef.current || selectedPlayoutIdRef.current !== playoutId) {
|
|
return;
|
|
}
|
|
|
|
setState((current) => {
|
|
if (current.status !== 'success') {
|
|
return current;
|
|
}
|
|
|
|
return {
|
|
data: { ...current.data, items: itemsPage.page ?? [] },
|
|
error: null,
|
|
itemsLoading: false,
|
|
status: 'success'
|
|
};
|
|
});
|
|
})
|
|
.catch((error: unknown) => {
|
|
if (!activeRef.current || selectedPlayoutIdRef.current !== playoutId) {
|
|
return;
|
|
}
|
|
|
|
setState({ data: null, error: messageFromPlayoutError(error), status: 'error' });
|
|
});
|
|
}, []);
|
|
|
|
if (state.status === 'success') {
|
|
return {
|
|
data: state.data,
|
|
error: null,
|
|
itemsLoading: state.itemsLoading,
|
|
refresh,
|
|
setActivePlayout,
|
|
setShowFiller,
|
|
showFiller,
|
|
status: 'success'
|
|
};
|
|
}
|
|
|
|
if (state.status === 'error') {
|
|
return { data: null, error: state.error, refresh, status: 'error' };
|
|
}
|
|
|
|
return { data: null, error: null, refresh, status: 'loading' };
|
|
}
|
|
|
|
function messageFromPlayoutError(error: unknown, fallback = 'Unable to load playouts'): string {
|
|
if (error instanceof ApiError) {
|
|
return error.detail ?? error.message;
|
|
}
|
|
|
|
if (error instanceof Error) {
|
|
return error.message;
|
|
}
|
|
|
|
return fallback;
|
|
}
|