301 lines
10 KiB
TypeScript
301 lines
10 KiB
TypeScript
import { randomUUID } from "node:crypto";
|
|
import type { ModuleHttpRouteRegistrar, ModuleRouteHandlerContext } from "@ekklesia/module-sdk";
|
|
import { SignageError, signageBoundary } from "../errors.js";
|
|
import {
|
|
isUuid,
|
|
optionalInstant,
|
|
readJsonObject,
|
|
requiredString,
|
|
requireUuidParam,
|
|
} from "../http.js";
|
|
import type { SignagePlaybackService } from "../playback/service.js";
|
|
import { createSignageStore } from "../store/drizzle.js";
|
|
import { SignageStoreConflict, type StoredChannelGroupDetail } from "../store/types.js";
|
|
|
|
/** An audience key is what a provider receives, so it uses the same flat lowercase grammar the rest
|
|
* of the platform uses for a local identifier. */
|
|
const AUDIENCE_KEY = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
|
|
|
|
function describeGroup(detail: StoredChannelGroupDetail): Record<string, unknown> {
|
|
return {
|
|
channels: detail.channels.map((channel) => ({
|
|
id: channel.id,
|
|
isDefault: channel.isDefault,
|
|
key: channel.key,
|
|
name: channel.name,
|
|
})),
|
|
id: detail.group.id,
|
|
name: detail.group.name,
|
|
revision: detail.group.revision,
|
|
};
|
|
}
|
|
|
|
export function registerPlaybackRoutes(
|
|
http: ModuleHttpRouteRegistrar,
|
|
playback: () => SignagePlaybackService,
|
|
): void {
|
|
http.route({
|
|
method: "GET",
|
|
path: "/channel-groups",
|
|
permission: "signage.view",
|
|
maxBodyBytes: 0,
|
|
handler(_request, context) {
|
|
return signageBoundary(async () => {
|
|
const groups = await createSignageStore(context.services.database).listChannelGroups();
|
|
return Response.json({
|
|
groups: await Promise.all(
|
|
groups.map(async (group) => ({
|
|
...describeGroup(group),
|
|
playback: await playback().snapshot(group.group.id),
|
|
})),
|
|
),
|
|
});
|
|
});
|
|
},
|
|
});
|
|
|
|
http.route({
|
|
method: "POST",
|
|
path: "/channel-groups",
|
|
permission: "signage.displays.manage",
|
|
maxBodyBytes: 4096,
|
|
handler(request, context) {
|
|
return signageBoundary(async () => {
|
|
const body = await readJsonObject(request);
|
|
const store = createSignageStore(context.services.database);
|
|
const groupId = randomUUID();
|
|
// A group is created with its default channel and its playback row together: a group
|
|
// without a default channel has nowhere for a viewer to land.
|
|
await store.createChannelGroup({
|
|
channelId: randomUUID(),
|
|
channelName: "Default",
|
|
groupId,
|
|
name: requiredString(body, "name", { maxLength: 120 }),
|
|
});
|
|
const created = await store.findChannelGroup(groupId);
|
|
if (!created) {
|
|
throw new SignageError("SIGNAGE_OPERATION_FAILED");
|
|
}
|
|
return Response.json(describeGroup(created), { status: 201 });
|
|
});
|
|
},
|
|
});
|
|
|
|
http.route({
|
|
method: "DELETE",
|
|
path: "/channel-groups/:groupId",
|
|
permission: "signage.displays.manage",
|
|
maxBodyBytes: 0,
|
|
handler(_request, context) {
|
|
return signageBoundary(async () => {
|
|
const groupId = requireUuidParam(context, "groupId");
|
|
const store = createSignageStore(context.services.database);
|
|
const groups = await store.listChannelGroups();
|
|
const group = groups.find((candidate) => candidate.group.id === groupId);
|
|
if (!group) {
|
|
throw new SignageError("SIGNAGE_NOT_FOUND");
|
|
}
|
|
if (groups.length <= 1) {
|
|
// An installation always has somewhere for a viewer to land.
|
|
throw new SignageError("SIGNAGE_CONFLICT", { reason: "last-group" });
|
|
}
|
|
const fallbackGroup = groups.find((candidate) => candidate.group.id !== groupId);
|
|
const fallbackChannel = fallbackGroup?.channels.find((channel) => channel.isDefault);
|
|
if (!fallbackChannel) {
|
|
throw new SignageError("SIGNAGE_CONFLICT", { reason: "no-fallback-channel" });
|
|
}
|
|
await store.deleteChannelGroup(groupId, fallbackChannel.id);
|
|
return new Response(null, { status: 204 });
|
|
});
|
|
},
|
|
});
|
|
|
|
http.route({
|
|
method: "POST",
|
|
path: "/channel-groups/:groupId/channels",
|
|
permission: "signage.displays.manage",
|
|
maxBodyBytes: 4096,
|
|
handler(request, context) {
|
|
return signageBoundary(async () => {
|
|
const groupId = requireUuidParam(context, "groupId");
|
|
const body = await readJsonObject(request);
|
|
const key = requiredString(body, "key", { maxLength: 64 });
|
|
if (!AUDIENCE_KEY.test(key) || key === "default") {
|
|
throw new SignageError("SIGNAGE_INVALID_REQUEST", { field: "key" });
|
|
}
|
|
const store = createSignageStore(context.services.database);
|
|
const group = await store.findChannelGroup(groupId);
|
|
if (!group) {
|
|
throw new SignageError("SIGNAGE_NOT_FOUND");
|
|
}
|
|
if (group.channels.some((channel) => channel.key === key)) {
|
|
throw new SignageError("SIGNAGE_CONFLICT", { field: "key" });
|
|
}
|
|
await store.addChannel({
|
|
groupId,
|
|
id: randomUUID(),
|
|
isDefault: false,
|
|
key,
|
|
name: requiredString(body, "name", { maxLength: 120 }),
|
|
});
|
|
const updated = await store.findChannelGroup(groupId);
|
|
if (!updated) {
|
|
throw new SignageError("SIGNAGE_OPERATION_FAILED");
|
|
}
|
|
return Response.json(describeGroup(updated), { status: 201 });
|
|
});
|
|
},
|
|
});
|
|
|
|
http.route({
|
|
method: "DELETE",
|
|
path: "/channels/:channelId",
|
|
permission: "signage.displays.manage",
|
|
maxBodyBytes: 0,
|
|
handler(_request, context) {
|
|
return signageBoundary(async () => {
|
|
const channelId = requireUuidParam(context, "channelId");
|
|
try {
|
|
await createSignageStore(context.services.database).removeChannel(channelId);
|
|
} catch (error) {
|
|
if (error instanceof SignageStoreConflict) {
|
|
// A group's default channel is the one a viewer lands on. It cannot be removed.
|
|
throw new SignageError("SIGNAGE_CONFLICT", { reason: "default-channel" });
|
|
}
|
|
throw error;
|
|
}
|
|
return new Response(null, { status: 204 });
|
|
});
|
|
},
|
|
});
|
|
|
|
http.route({
|
|
method: "GET",
|
|
path: "/playback/:groupId",
|
|
permission: "signage.view",
|
|
maxBodyBytes: 0,
|
|
handler(_request, context) {
|
|
return signageBoundary(async () => {
|
|
const groupId = requireUuidParam(context, "groupId");
|
|
const store = createSignageStore(context.services.database);
|
|
const snapshot = await playback().snapshot(groupId);
|
|
const selection =
|
|
snapshot.currentSelectionId === null
|
|
? undefined
|
|
: await store.findSelection(snapshot.currentSelectionId);
|
|
const history = await store.listSelections(groupId, 20);
|
|
return Response.json({
|
|
current:
|
|
selection === undefined
|
|
? null
|
|
: {
|
|
deadlineAtMs: selection.deadlineAt?.getTime() ?? null,
|
|
durationMs: selection.durationMs,
|
|
id: selection.id,
|
|
itemId: selection.itemId,
|
|
itemRevision: selection.itemRevision,
|
|
providerId: selection.providerId,
|
|
rendererContributionId: selection.rendererContributionId,
|
|
revision: selection.revision,
|
|
stale: selection.stale,
|
|
startedAtMs: selection.startedAt?.getTime() ?? null,
|
|
withdrawn: selection.withdrawn,
|
|
},
|
|
// Identity and timing only. A payload belongs to a display, which asks for the channel
|
|
// state it is authorized for.
|
|
history: history.map((entry) => ({
|
|
id: entry.id,
|
|
itemId: entry.itemId,
|
|
providerId: entry.providerId,
|
|
sequence: entry.sequence,
|
|
startedAtMs: entry.startedAt?.getTime() ?? null,
|
|
})),
|
|
snapshot,
|
|
});
|
|
});
|
|
},
|
|
});
|
|
|
|
function command(
|
|
path: string,
|
|
run: (
|
|
service: SignagePlaybackService,
|
|
groupId: string,
|
|
body: Record<string, unknown>,
|
|
context: ModuleRouteHandlerContext,
|
|
) => Promise<unknown>,
|
|
options: { readonly maxBodyBytes: number },
|
|
): void {
|
|
http.route({
|
|
method: "POST",
|
|
path,
|
|
permission: "signage.playback.control",
|
|
maxBodyBytes: options.maxBodyBytes,
|
|
handler(request, context) {
|
|
return signageBoundary(async () => {
|
|
const groupId = requireUuidParam(context, "groupId");
|
|
const body = options.maxBodyBytes === 0 ? {} : await readJsonObject(request);
|
|
return Response.json(await run(playback(), groupId, body, context));
|
|
});
|
|
},
|
|
});
|
|
}
|
|
|
|
command(
|
|
"/playback/:groupId/activate",
|
|
async (service, groupId, body) => {
|
|
const timelineId = body.timelineId;
|
|
if (!isUuid(timelineId)) {
|
|
throw new SignageError("SIGNAGE_INVALID_REQUEST", { field: "timelineId" });
|
|
}
|
|
const at = optionalInstant(body, "at");
|
|
if (at) {
|
|
return service.activate(groupId, timelineId, { at });
|
|
}
|
|
const when = body.when === "next-boundary" ? "next-boundary" : "now";
|
|
return service.activate(groupId, timelineId, when);
|
|
},
|
|
{ maxBodyBytes: 2048 },
|
|
);
|
|
|
|
command("/playback/:groupId/pause", (service, groupId) => service.pause(groupId), {
|
|
maxBodyBytes: 0,
|
|
});
|
|
command("/playback/:groupId/resume", (service, groupId) => service.resume(groupId), {
|
|
maxBodyBytes: 0,
|
|
});
|
|
command("/playback/:groupId/next", (service, groupId) => service.next(groupId), {
|
|
maxBodyBytes: 0,
|
|
});
|
|
command("/playback/:groupId/previous", (service, groupId) => service.previous(groupId), {
|
|
maxBodyBytes: 0,
|
|
});
|
|
command("/playback/:groupId/reload", (service, groupId) => service.reload(groupId), {
|
|
maxBodyBytes: 0,
|
|
});
|
|
command(
|
|
"/playback/:groupId/blackout",
|
|
(service, groupId, body) => {
|
|
if (typeof body.on !== "boolean") {
|
|
throw new SignageError("SIGNAGE_INVALID_REQUEST", { field: "on" });
|
|
}
|
|
return service.setBlackout(groupId, body.on);
|
|
},
|
|
{ maxBodyBytes: 1024 },
|
|
);
|
|
command(
|
|
"/playback/:groupId/static",
|
|
(service, groupId, body) => {
|
|
const assetId = body.assetId;
|
|
if (assetId === null) {
|
|
return service.setStaticHold(groupId, null);
|
|
}
|
|
if (!isUuid(assetId)) {
|
|
throw new SignageError("SIGNAGE_INVALID_REQUEST", { field: "assetId" });
|
|
}
|
|
return service.setStaticHold(groupId, assetId);
|
|
},
|
|
{ maxBodyBytes: 1024 },
|
|
);
|
|
}
|