1239 lines
38 KiB
TypeScript
1239 lines
38 KiB
TypeScript
import { createHash, randomBytes, randomUUID } from 'node:crypto';
|
|
import { readFile } from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import type Database from 'better-sqlite3';
|
|
import { getServerPaths } from './config.js';
|
|
import { getDatabase } from './database.js';
|
|
import { renderMarkdown } from './markdown.js';
|
|
import { buildEmbedUrl, fetchPresentationImage, type PresentationContent } from './presentation.js';
|
|
import {
|
|
getShow,
|
|
movePieceUsage,
|
|
type MovePieceUsageInput,
|
|
type PieceUsage,
|
|
type ShowStatus,
|
|
type ShowSection
|
|
} from './shows.js';
|
|
|
|
type LiveStateRow = {
|
|
show_id: string;
|
|
revision: number;
|
|
current_usage_id: string | null;
|
|
started_at_utc: string | null;
|
|
ended_at_utc: string | null;
|
|
presentation_usage_id: string | null;
|
|
presentation_revision: number;
|
|
updated_at_utc: string;
|
|
};
|
|
|
|
type OrderedUsageRow = {
|
|
id: string;
|
|
section_id: string;
|
|
section_name: string;
|
|
section_position: number;
|
|
position: number;
|
|
status: PieceUsage['status'];
|
|
};
|
|
|
|
export type LiveUsage = PieceUsage & {
|
|
sectionId: string;
|
|
sectionName: string;
|
|
actualDurationSeconds: number;
|
|
introHtml: string;
|
|
researchHtml: string;
|
|
moderationHtml: string;
|
|
interactionHtml: string;
|
|
transitionHtml: string;
|
|
};
|
|
|
|
export type LiveSection = Omit<ShowSection, 'usages'> & { usages: LiveUsage[] };
|
|
|
|
export type LiveView = {
|
|
show: {
|
|
id: string;
|
|
title: string;
|
|
status: string;
|
|
revision: number;
|
|
totalDurationSeconds: number;
|
|
};
|
|
liveRevision: number;
|
|
calculatedAtUtc: string;
|
|
startedAtUtc: string | null;
|
|
endedAtUtc: string | null;
|
|
isPaused: boolean;
|
|
updatedAtUtc: string;
|
|
presentationUsageId: string | null;
|
|
presentationRevision: number;
|
|
sections: LiveSection[];
|
|
reserve: LiveUsage[];
|
|
current: LiveUsage | null;
|
|
next: LiveUsage | null;
|
|
completedCount: number;
|
|
totalCount: number;
|
|
sectionTimer: null | {
|
|
sectionId: string;
|
|
sectionName: string;
|
|
plannedDurationSeconds: number;
|
|
elapsedSeconds: number;
|
|
runningSinceUtc: string | null;
|
|
};
|
|
totalTimer: {
|
|
elapsedSeconds: number;
|
|
runningSinceUtc: string | null;
|
|
};
|
|
remainingEstimate: {
|
|
seconds: number;
|
|
activeCountdownSeconds: number;
|
|
unplannedSectionCount: number;
|
|
};
|
|
};
|
|
|
|
export type PresentationView = {
|
|
revision: number;
|
|
content: null | {
|
|
mode: PresentationContent['mode'];
|
|
topics: string[];
|
|
title: string;
|
|
html: string;
|
|
source: PresentationContent['source'];
|
|
previewTitle: string;
|
|
description: string;
|
|
imageUrl: string;
|
|
siteName: string;
|
|
provider: PresentationContent['provider'];
|
|
providerId: string;
|
|
embedUrl: string;
|
|
sources: { label: string; url: string; timecodeSeconds: number | null }[];
|
|
images: { id: string; altText: string }[];
|
|
};
|
|
};
|
|
|
|
function hashToken(token: string) {
|
|
return createHash('sha256').update(token).digest('hex');
|
|
}
|
|
|
|
function nowIso(now?: Date) {
|
|
return (now ?? new Date()).toISOString();
|
|
}
|
|
|
|
function requireCommandId(commandId: string) {
|
|
if (!commandId || commandId.length > 200) throw new Error('INVALID_COMMAND');
|
|
}
|
|
|
|
function ensureLiveState(database: Database.Database, showId: string, now: string): LiveStateRow {
|
|
const show = database.prepare('SELECT 1 FROM shows WHERE id = ?').get(showId);
|
|
if (!show) throw new Error('NOT_FOUND');
|
|
database
|
|
.prepare(
|
|
`INSERT OR IGNORE INTO show_live_states (show_id, updated_at_utc)
|
|
VALUES (?, ?)`
|
|
)
|
|
.run(showId, now);
|
|
return database
|
|
.prepare('SELECT * FROM show_live_states WHERE show_id = ?')
|
|
.get(showId) as LiveStateRow;
|
|
}
|
|
|
|
function orderedUsages(database: Database.Database, showId: string): OrderedUsageRow[] {
|
|
return database
|
|
.prepare(
|
|
`SELECT u.id, s.id AS section_id, s.name AS section_name,
|
|
s.position AS section_position, u.position, u.status
|
|
FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE s.show_id = ? AND s.is_reserve_bank = 0
|
|
ORDER BY s.position, u.position`
|
|
)
|
|
.all(showId) as OrderedUsageRow[];
|
|
}
|
|
|
|
function usageBelongsToShow(database: Database.Database, showId: string, usageId: string) {
|
|
const row = database
|
|
.prepare(
|
|
`SELECT s.is_reserve_bank FROM piece_usages u
|
|
JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE u.id = ? AND s.show_id = ?`
|
|
)
|
|
.get(usageId, showId) as { is_reserve_bank: number } | undefined;
|
|
if (!row || row.is_reserve_bank) throw new Error('NOT_FOUND');
|
|
}
|
|
|
|
function closeActiveRun(database: Database.Database, showId: string, now: string) {
|
|
database
|
|
.prepare(
|
|
`UPDATE live_usage_runs SET ended_at_utc = ?
|
|
WHERE show_id = ? AND ended_at_utc IS NULL`
|
|
)
|
|
.run(now, showId);
|
|
}
|
|
|
|
function closeShowTimerRun(database: Database.Database, showId: string, now: string) {
|
|
database
|
|
.prepare(
|
|
`UPDATE live_show_timer_runs SET ended_at_utc = ?
|
|
WHERE show_id = ? AND ended_at_utc IS NULL`
|
|
)
|
|
.run(now, showId);
|
|
}
|
|
|
|
function openShowTimerRun(database: Database.Database, showId: string, now: string) {
|
|
const active = database
|
|
.prepare('SELECT 1 FROM live_show_timer_runs WHERE show_id = ? AND ended_at_utc IS NULL')
|
|
.get(showId);
|
|
if (!active) {
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_show_timer_runs (id, show_id, started_at_utc)
|
|
VALUES (?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), showId, now);
|
|
}
|
|
}
|
|
|
|
function showTimerRunning(database: Database.Database, showId: string) {
|
|
return Boolean(
|
|
database
|
|
.prepare('SELECT 1 FROM live_show_timer_runs WHERE show_id = ? AND ended_at_utc IS NULL')
|
|
.get(showId)
|
|
);
|
|
}
|
|
|
|
function elapsedRuns(runs: { started_at_utc: string; ended_at_utc: string | null }[], now: string) {
|
|
return runs.reduce(
|
|
(total, run) =>
|
|
total +
|
|
Math.max(
|
|
0,
|
|
Math.floor(
|
|
(new Date(run.ended_at_utc ?? now).getTime() - new Date(run.started_at_utc).getTime()) /
|
|
1_000
|
|
)
|
|
),
|
|
0
|
|
);
|
|
}
|
|
|
|
function closeSectionTimer(database: Database.Database, showId: string, now: string) {
|
|
const timer = database
|
|
.prepare('SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL')
|
|
.get(showId) as { id: string } | undefined;
|
|
if (!timer) return;
|
|
database
|
|
.prepare(
|
|
'UPDATE live_section_timer_runs SET ended_at_utc = ? WHERE timer_id = ? AND ended_at_utc IS NULL'
|
|
)
|
|
.run(now, timer.id);
|
|
database
|
|
.prepare('UPDATE live_section_timers SET ended_at_utc = ? WHERE id = ?')
|
|
.run(now, timer.id);
|
|
}
|
|
|
|
function resumeSectionTimerRun(database: Database.Database, showId: string, now: string) {
|
|
const timer = database
|
|
.prepare('SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL')
|
|
.get(showId) as { id: string } | undefined;
|
|
if (!timer) return;
|
|
const running = database
|
|
.prepare('SELECT 1 FROM live_section_timer_runs WHERE timer_id = ? AND ended_at_utc IS NULL')
|
|
.get(timer.id);
|
|
if (!running) {
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
|
|
VALUES (?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), timer.id, now);
|
|
}
|
|
}
|
|
|
|
function syncSectionTimer(
|
|
database: Database.Database,
|
|
showId: string,
|
|
usageId: string,
|
|
now: string
|
|
) {
|
|
const section = database
|
|
.prepare(
|
|
`SELECT s.id, s.explicit_duration_seconds FROM piece_usages u
|
|
JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE u.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0`
|
|
)
|
|
.get(usageId, showId) as { id: string; explicit_duration_seconds: number | null } | undefined;
|
|
if (!section) throw new Error('NOT_FOUND');
|
|
const active = database
|
|
.prepare(
|
|
'SELECT id, section_id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL'
|
|
)
|
|
.get(showId) as { id: string; section_id: string } | undefined;
|
|
if (active?.section_id === section.id) return;
|
|
if (active) closeSectionTimer(database, showId, now);
|
|
if (!section.explicit_duration_seconds || section.explicit_duration_seconds <= 0) return;
|
|
const timerId = randomUUID();
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_section_timers
|
|
(id, show_id, section_id, planned_duration_seconds, started_at_utc)
|
|
VALUES (?, ?, ?, ?, ?)`
|
|
)
|
|
.run(timerId, showId, section.id, section.explicit_duration_seconds, now);
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
|
|
VALUES (?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), timerId, now);
|
|
}
|
|
|
|
function activateUsage(database: Database.Database, showId: string, usageId: string, now: string) {
|
|
usageBelongsToShow(database, showId, usageId);
|
|
database
|
|
.prepare(
|
|
`UPDATE piece_usages SET status = 'open'
|
|
WHERE status = 'current' AND id != ? AND id IN (
|
|
SELECT u.id FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE s.show_id = ?
|
|
)`
|
|
)
|
|
.run(usageId, showId);
|
|
database.prepare(`UPDATE piece_usages SET status = 'current' WHERE id = ?`).run(usageId);
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
|
|
VALUES (?, ?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), showId, usageId, now);
|
|
database
|
|
.prepare(
|
|
'UPDATE show_live_states SET current_usage_id = ?, ended_at_utc = NULL WHERE show_id = ?'
|
|
)
|
|
.run(usageId, showId);
|
|
syncSectionTimer(database, showId, usageId, now);
|
|
}
|
|
|
|
function executeCommand(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
action: string,
|
|
operation: (database: Database.Database, state: LiveStateRow, now: string) => void,
|
|
nowValue?: Date,
|
|
allowCompleted = false
|
|
) {
|
|
requireCommandId(commandId);
|
|
const database = getDatabase();
|
|
return database.transaction(() => {
|
|
const duplicate = database
|
|
.prepare('SELECT result_revision FROM live_commands WHERE show_id = ? AND command_id = ?')
|
|
.get(showId, commandId) as { result_revision: number } | undefined;
|
|
if (duplicate) return { revision: duplicate.result_revision, duplicate: true };
|
|
const now = nowIso(nowValue);
|
|
const state = ensureLiveState(database, showId, now);
|
|
const show = database.prepare('SELECT status FROM shows WHERE id = ?').get(showId) as {
|
|
status: string;
|
|
};
|
|
if (database.prepare('SELECT 1 FROM show_finalizations WHERE show_id = ?').get(showId)) {
|
|
throw new Error('SHOW_COMPLETED');
|
|
}
|
|
if (show.status === 'completed' && !allowCompleted) throw new Error('SHOW_COMPLETED');
|
|
if (state.revision !== expectedRevision) throw new Error('CONFLICT');
|
|
operation(database, state, now);
|
|
const updated = database
|
|
.prepare(
|
|
`UPDATE show_live_states SET revision = revision + 1, updated_at_utc = ?
|
|
WHERE show_id = ? AND revision = ?`
|
|
)
|
|
.run(now, showId, expectedRevision);
|
|
if (updated.changes !== 1) throw new Error('CONFLICT');
|
|
const revision = expectedRevision + 1;
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_commands (show_id, command_id, action, result_revision, created_at_utc)
|
|
VALUES (?, ?, ?, ?, ?)`
|
|
)
|
|
.run(showId, commandId, action, revision, now);
|
|
return { revision, duplicate: false };
|
|
})();
|
|
}
|
|
|
|
function actualDurations(database: Database.Database, showId: string, now: string) {
|
|
const rows = database
|
|
.prepare(
|
|
`SELECT usage_id, started_at_utc, ended_at_utc
|
|
FROM live_usage_runs WHERE show_id = ?`
|
|
)
|
|
.all(showId) as { usage_id: string; started_at_utc: string; ended_at_utc: string | null }[];
|
|
const durations = new Map<string, number>();
|
|
for (const row of rows) {
|
|
const seconds = Math.max(
|
|
0,
|
|
Math.floor(
|
|
(new Date(row.ended_at_utc ?? now).getTime() - new Date(row.started_at_utc).getTime()) /
|
|
1000
|
|
)
|
|
);
|
|
durations.set(row.usage_id, (durations.get(row.usage_id) ?? 0) + seconds);
|
|
}
|
|
return durations;
|
|
}
|
|
|
|
function liveUsage(
|
|
usage: PieceUsage,
|
|
sectionId: string,
|
|
sectionName: string,
|
|
actualSeconds: number
|
|
) {
|
|
return {
|
|
...usage,
|
|
sectionId,
|
|
sectionName,
|
|
actualDurationSeconds: actualSeconds,
|
|
introHtml: renderMarkdown(usage.intro),
|
|
researchHtml: renderMarkdown(usage.research),
|
|
moderationHtml: renderMarkdown(usage.moderation),
|
|
interactionHtml: renderMarkdown(usage.interaction),
|
|
transitionHtml: renderMarkdown(usage.transition)
|
|
};
|
|
}
|
|
|
|
export function getLiveView(showId: string, nowValue?: Date): LiveView {
|
|
const database = getDatabase();
|
|
const now = nowIso(nowValue);
|
|
const state = ensureLiveState(database, showId, now);
|
|
const show = getShow(showId);
|
|
if (!show) throw new Error('NOT_FOUND');
|
|
const durations = actualDurations(database, showId, now);
|
|
const sections = show.sections.map((section) => ({
|
|
...section,
|
|
usages: section.usages.map((usage) =>
|
|
liveUsage(usage, section.id, section.name, durations.get(usage.id) ?? 0)
|
|
)
|
|
}));
|
|
const reserve = show.reserve.map((usage) =>
|
|
liveUsage(usage, '', 'Reservebank', durations.get(usage.id) ?? 0)
|
|
);
|
|
const usages = sections.flatMap((section) => section.usages);
|
|
const current = usages.find((usage) => usage.id === state.current_usage_id) ?? null;
|
|
const currentIndex = current ? usages.findIndex((usage) => usage.id === current.id) : -1;
|
|
const next =
|
|
usages.slice(currentIndex + 1).find((usage) => usage.status === 'open') ??
|
|
(current ? null : (usages.find((usage) => usage.status === 'open') ?? null));
|
|
const timer = database
|
|
.prepare(
|
|
`SELECT t.id, t.section_id, s.name AS section_name, t.planned_duration_seconds
|
|
FROM live_section_timers t JOIN show_sections s ON s.id = t.section_id
|
|
WHERE t.show_id = ? AND t.ended_at_utc IS NULL`
|
|
)
|
|
.get(showId) as
|
|
| { id: string; section_id: string; section_name: string; planned_duration_seconds: number }
|
|
| undefined;
|
|
let sectionTimer: LiveView['sectionTimer'] = null;
|
|
if (timer) {
|
|
const runs = database
|
|
.prepare(
|
|
`SELECT started_at_utc, ended_at_utc FROM live_section_timer_runs
|
|
WHERE timer_id = ? ORDER BY started_at_utc`
|
|
)
|
|
.all(timer.id) as { started_at_utc: string; ended_at_utc: string | null }[];
|
|
const running = runs.find((run) => run.ended_at_utc === null) ?? null;
|
|
const elapsedSeconds = elapsedRuns(runs, now);
|
|
sectionTimer = {
|
|
sectionId: timer.section_id,
|
|
sectionName: timer.section_name,
|
|
plannedDurationSeconds: timer.planned_duration_seconds,
|
|
elapsedSeconds,
|
|
runningSinceUtc: running?.started_at_utc ?? null
|
|
};
|
|
}
|
|
const totalTimerRuns = database
|
|
.prepare(
|
|
`SELECT started_at_utc, ended_at_utc FROM live_show_timer_runs
|
|
WHERE show_id = ? ORDER BY started_at_utc`
|
|
)
|
|
.all(showId) as { started_at_utc: string; ended_at_utc: string | null }[];
|
|
const runningTotalTimer = totalTimerRuns.find((run) => run.ended_at_utc === null) ?? null;
|
|
const totalElapsedSeconds = elapsedRuns(totalTimerRuns, now);
|
|
const remainingAnchor = current ?? next;
|
|
let reachedRemaining = !remainingAnchor;
|
|
let remainingSeconds = 0;
|
|
let activeCountdownSeconds = 0;
|
|
let unplannedSectionCount = 0;
|
|
for (const section of sections) {
|
|
if (section.id === remainingAnchor?.sectionId) reachedRemaining = true;
|
|
if (!reachedRemaining) continue;
|
|
const remainingUsages = section.usages.filter(
|
|
(usage) => usage.status === 'open' || usage.status === 'current'
|
|
);
|
|
if (remainingUsages.length === 0) continue;
|
|
|
|
if (section.id === current?.sectionId) {
|
|
if (section.durationSeconds > 0 && sectionTimer?.sectionId === section.id) {
|
|
activeCountdownSeconds = Math.max(0, section.durationSeconds - sectionTimer.elapsedSeconds);
|
|
remainingSeconds += activeCountdownSeconds;
|
|
} else {
|
|
remainingSeconds += remainingUsages.reduce((total, usage) => {
|
|
const elapsed = usage.id === current?.id ? usage.actualDurationSeconds : 0;
|
|
const remainder = Math.max(0, usage.durationSeconds - elapsed);
|
|
if (usage.id === current?.id) activeCountdownSeconds = remainder;
|
|
return total + remainder;
|
|
}, 0);
|
|
if (section.durationSeconds <= 0) unplannedSectionCount += 1;
|
|
}
|
|
} else if (section.durationSeconds > 0) {
|
|
remainingSeconds += section.durationSeconds;
|
|
} else {
|
|
remainingSeconds += remainingUsages.reduce(
|
|
(total, usage) => total + usage.durationSeconds,
|
|
0
|
|
);
|
|
unplannedSectionCount += 1;
|
|
}
|
|
}
|
|
return {
|
|
show: {
|
|
id: show.id,
|
|
title: show.title,
|
|
status: show.status,
|
|
revision: show.revision,
|
|
totalDurationSeconds: show.totalDurationSeconds
|
|
},
|
|
liveRevision: state.revision,
|
|
calculatedAtUtc: now,
|
|
startedAtUtc: state.started_at_utc,
|
|
endedAtUtc: state.ended_at_utc,
|
|
isPaused: Boolean(state.started_at_utc && !state.ended_at_utc && !runningTotalTimer),
|
|
updatedAtUtc: state.updated_at_utc,
|
|
presentationUsageId: state.presentation_usage_id,
|
|
presentationRevision: state.presentation_revision,
|
|
sections,
|
|
reserve,
|
|
current,
|
|
next,
|
|
completedCount: usages.filter((usage) => usage.status === 'done' || usage.status === 'skipped')
|
|
.length,
|
|
totalCount: usages.length,
|
|
sectionTimer,
|
|
totalTimer: {
|
|
elapsedSeconds: totalElapsedSeconds,
|
|
runningSinceUtc: runningTotalTimer?.started_at_utc ?? null
|
|
},
|
|
remainingEstimate: {
|
|
seconds: remainingSeconds,
|
|
activeCountdownSeconds,
|
|
unplannedSectionCount
|
|
}
|
|
};
|
|
}
|
|
|
|
export function startOrResumeLive(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'start',
|
|
(database, state, now) => {
|
|
database
|
|
.prepare(
|
|
`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ?
|
|
WHERE id = ? AND status != 'completed'`
|
|
)
|
|
.run(now, showId);
|
|
database
|
|
.prepare(
|
|
`UPDATE show_live_states SET started_at_utc = COALESCE(started_at_utc, ?), ended_at_utc = NULL
|
|
WHERE show_id = ?`
|
|
)
|
|
.run(now, showId);
|
|
openShowTimerRun(database, showId, now);
|
|
const activeRun = database
|
|
.prepare('SELECT 1 FROM live_usage_runs WHERE show_id = ? AND ended_at_utc IS NULL')
|
|
.get(showId);
|
|
if (state.current_usage_id && activeRun) {
|
|
resumeSectionTimerRun(database, showId, now);
|
|
return;
|
|
}
|
|
const current = state.current_usage_id
|
|
? orderedUsages(database, showId).find((usage) => usage.id === state.current_usage_id)
|
|
: undefined;
|
|
const target =
|
|
current ?? orderedUsages(database, showId).find((usage) => usage.status === 'open');
|
|
if (target) activateUsage(database, showId, target.id, now);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function pauseLive(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'pause',
|
|
(database, state, now) => {
|
|
if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
|
|
if (!showTimerRunning(database, showId)) throw new Error('ALREADY_PAUSED');
|
|
closeShowTimerRun(database, showId, now);
|
|
closeActiveRun(database, showId, now);
|
|
database
|
|
.prepare(
|
|
`UPDATE live_section_timer_runs SET ended_at_utc = ?
|
|
WHERE timer_id IN (
|
|
SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL
|
|
) AND ended_at_utc IS NULL`
|
|
)
|
|
.run(now, showId);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function resumeLive(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'resume',
|
|
(database, state, now) => {
|
|
if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
|
|
if (showTimerRunning(database, showId)) throw new Error('ALREADY_RUNNING');
|
|
openShowTimerRun(database, showId, now);
|
|
if (state.current_usage_id) {
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
|
|
VALUES (?, ?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), showId, state.current_usage_id, now);
|
|
}
|
|
resumeSectionTimerRun(database, showId, now);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function resetSectionTimer(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'reset-section-timer',
|
|
(database, _state, now) => {
|
|
const timer = database
|
|
.prepare(
|
|
`SELECT section_id, planned_duration_seconds
|
|
FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL`
|
|
)
|
|
.get(showId) as { section_id: string; planned_duration_seconds: number } | undefined;
|
|
if (!timer) throw new Error('NO_SECTION_TIMER');
|
|
const running = showTimerRunning(database, showId);
|
|
closeSectionTimer(database, showId, now);
|
|
const timerId = randomUUID();
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_section_timers
|
|
(id, show_id, section_id, planned_duration_seconds, started_at_utc)
|
|
VALUES (?, ?, ?, ?, ?)`
|
|
)
|
|
.run(timerId, showId, timer.section_id, timer.planned_duration_seconds, now);
|
|
if (running) {
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
|
|
VALUES (?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), timerId, now);
|
|
}
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function resetTotalTimer(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'reset-total-timer',
|
|
(database, state, now) => {
|
|
if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
|
|
const running = showTimerRunning(database, showId);
|
|
database.prepare('DELETE FROM live_show_timer_runs WHERE show_id = ?').run(showId);
|
|
if (running) openShowTimerRun(database, showId, now);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function setShowStatus(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
expectedShowRevision: number,
|
|
status: Extract<ShowStatus, 'draft' | 'ready'>,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
`status-${status}`,
|
|
(database, state, now) => {
|
|
if (state.started_at_utc) throw new Error('ALREADY_STARTED');
|
|
const result = database
|
|
.prepare(
|
|
'UPDATE shows SET status = ?, revision = revision + 1, updated_at_utc = ? WHERE id = ? AND revision = ?'
|
|
)
|
|
.run(status, now, showId, expectedShowRevision);
|
|
if (result.changes !== 1) throw new Error('CONFLICT');
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function endLive(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'end',
|
|
(database, state, now) => {
|
|
if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
|
|
closeShowTimerRun(database, showId, now);
|
|
closeActiveRun(database, showId, now);
|
|
database
|
|
.prepare(
|
|
`UPDATE live_section_timer_runs SET ended_at_utc = ?
|
|
WHERE timer_id IN (
|
|
SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL
|
|
) AND ended_at_utc IS NULL`
|
|
)
|
|
.run(now, showId);
|
|
database
|
|
.prepare(`UPDATE show_live_states SET ended_at_utc = ? WHERE show_id = ?`)
|
|
.run(now, showId);
|
|
database
|
|
.prepare(`UPDATE shows SET revision = revision + 1, updated_at_utc = ? WHERE id = ?`)
|
|
.run(now, showId);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function resumeEndedLive(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'resume-ended',
|
|
(database, state, now) => {
|
|
if (!state.ended_at_utc) throw new Error('NOT_ENDED');
|
|
database
|
|
.prepare(
|
|
`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`
|
|
)
|
|
.run(now, showId);
|
|
database
|
|
.prepare('UPDATE show_live_states SET ended_at_utc = NULL WHERE show_id = ?')
|
|
.run(showId);
|
|
openShowTimerRun(database, showId, now);
|
|
if (state.current_usage_id) {
|
|
database
|
|
.prepare(
|
|
`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
|
|
VALUES (?, ?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), showId, state.current_usage_id, now);
|
|
resumeSectionTimerRun(database, showId, now);
|
|
}
|
|
},
|
|
nowValue,
|
|
true
|
|
);
|
|
}
|
|
|
|
export function startNewLiveRun(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'start-new-run',
|
|
(database, state, now) => {
|
|
if (!state.ended_at_utc) throw new Error('NOT_ENDED');
|
|
database.prepare('DELETE FROM live_usage_runs WHERE show_id = ?').run(showId);
|
|
database.prepare('DELETE FROM live_show_timer_runs WHERE show_id = ?').run(showId);
|
|
database.prepare('DELETE FROM live_section_timers WHERE show_id = ?').run(showId);
|
|
database
|
|
.prepare(
|
|
`UPDATE piece_usages SET status = 'open'
|
|
WHERE show_section_id IN (SELECT id FROM show_sections WHERE show_id = ?)`
|
|
)
|
|
.run(showId);
|
|
database
|
|
.prepare(
|
|
`UPDATE show_live_states
|
|
SET current_usage_id = NULL, started_at_utc = ?, ended_at_utc = NULL
|
|
WHERE show_id = ?`
|
|
)
|
|
.run(now, showId);
|
|
database
|
|
.prepare(
|
|
`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`
|
|
)
|
|
.run(now, showId);
|
|
openShowTimerRun(database, showId, now);
|
|
const target = orderedUsages(database, showId).find((usage) => usage.status === 'open');
|
|
if (target) activateUsage(database, showId, target.id, now);
|
|
},
|
|
nowValue,
|
|
true
|
|
);
|
|
}
|
|
|
|
function advanceCurrent(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
status: 'done' | 'skipped',
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
status,
|
|
(database, state, now) => {
|
|
if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
|
|
if (!state.current_usage_id) throw new Error('NO_CURRENT');
|
|
const ordered = orderedUsages(database, showId);
|
|
const currentIndex = ordered.findIndex((usage) => usage.id === state.current_usage_id);
|
|
if (currentIndex < 0) throw new Error('NOT_FOUND');
|
|
closeActiveRun(database, showId, now);
|
|
database
|
|
.prepare('UPDATE piece_usages SET status = ? WHERE id = ?')
|
|
.run(status, state.current_usage_id);
|
|
const next = ordered.slice(currentIndex + 1).find((usage) => usage.status === 'open');
|
|
if (next) activateUsage(database, showId, next.id, now);
|
|
else {
|
|
closeSectionTimer(database, showId, now);
|
|
database
|
|
.prepare('UPDATE show_live_states SET current_usage_id = NULL WHERE show_id = ?')
|
|
.run(showId);
|
|
}
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function completeCurrent(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return advanceCurrent(showId, commandId, expectedRevision, 'done', nowValue);
|
|
}
|
|
|
|
export function skipCurrent(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return advanceCurrent(showId, commandId, expectedRevision, 'skipped', nowValue);
|
|
}
|
|
|
|
export function goBack(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'back',
|
|
(database, state, now) => {
|
|
if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
|
|
const ordered = orderedUsages(database, showId);
|
|
const currentIndex = state.current_usage_id
|
|
? ordered.findIndex((usage) => usage.id === state.current_usage_id)
|
|
: ordered.length;
|
|
const previous = ordered
|
|
.slice(0, Math.max(0, currentIndex))
|
|
.reverse()
|
|
.find((usage) => usage.status === 'done' || usage.status === 'skipped');
|
|
if (!previous) throw new Error('NO_PREVIOUS');
|
|
if (state.current_usage_id) {
|
|
closeActiveRun(database, showId, now);
|
|
database
|
|
.prepare(`UPDATE piece_usages SET status = 'open' WHERE id = ?`)
|
|
.run(state.current_usage_id);
|
|
}
|
|
activateUsage(database, showId, previous.id, now);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function selectUsage(
|
|
showId: string,
|
|
usageId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
'select',
|
|
(database, state, now) => {
|
|
if (!state.started_at_utc) throw new Error('NOT_STARTED');
|
|
if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
|
|
usageBelongsToShow(database, showId, usageId);
|
|
if (state.current_usage_id === usageId) return;
|
|
if (state.current_usage_id) {
|
|
closeActiveRun(database, showId, now);
|
|
database
|
|
.prepare("UPDATE piece_usages SET status = 'open' WHERE id = ?")
|
|
.run(state.current_usage_id);
|
|
}
|
|
activateUsage(database, showId, usageId, now);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function presentUsage(
|
|
showId: string,
|
|
usageId: string | null,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
usageId ? 'present' : 'clear-presentation',
|
|
(database, _state, now) => {
|
|
if (usageId) usageBelongsToShow(database, showId, usageId);
|
|
database
|
|
.prepare(
|
|
`UPDATE show_live_states SET presentation_usage_id = ?,
|
|
presentation_revision = presentation_revision + 1, updated_at_utc = ?
|
|
WHERE show_id = ?`
|
|
)
|
|
.run(usageId, now, showId);
|
|
},
|
|
nowValue
|
|
);
|
|
}
|
|
|
|
export function moveOpenUsage(
|
|
showId: string,
|
|
usageId: string,
|
|
expectedShowRevision: number,
|
|
input: MovePieceUsageInput
|
|
) {
|
|
const database = getDatabase();
|
|
const usage = database
|
|
.prepare(
|
|
`SELECT u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE u.id = ? AND s.show_id = ?`
|
|
)
|
|
.get(usageId, showId) as { status: PieceUsage['status'] } | undefined;
|
|
if (!usage) throw new Error('NOT_FOUND');
|
|
if (usage.status !== 'open') throw new Error('LIVE_ORDER_LOCKED');
|
|
if (input.sectionId) {
|
|
const target = database
|
|
.prepare(
|
|
`SELECT u.id, u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE s.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0 ORDER BY u.position`
|
|
)
|
|
.all(input.sectionId, showId) as { id: string; status: PieceUsage['status'] }[];
|
|
if (!target.length) {
|
|
const section = database
|
|
.prepare('SELECT 1 FROM show_sections WHERE id = ? AND show_id = ? AND is_reserve_bank = 0')
|
|
.get(input.sectionId, showId);
|
|
if (!section) throw new Error('NOT_FOUND');
|
|
}
|
|
const withoutMoved = target.filter((item) => item.id !== usageId);
|
|
const firstOpenPosition = withoutMoved.findIndex((item) => item.status === 'open');
|
|
const minimum = firstOpenPosition < 0 ? withoutMoved.length : firstOpenPosition;
|
|
if (input.position < minimum) throw new Error('LIVE_ORDER_LOCKED');
|
|
}
|
|
return movePieceUsage(showId, usageId, expectedShowRevision, input);
|
|
}
|
|
|
|
export function issuePresentationAccess(showId: string) {
|
|
const database = getDatabase();
|
|
const now = nowIso();
|
|
ensureLiveState(database, showId, now);
|
|
return database.transaction(() => {
|
|
let channel = database
|
|
.prepare("SELECT * FROM presentation_channels WHERE id = 'default'")
|
|
.get() as { access_key: string; show_id: string | null } | undefined;
|
|
if (!channel) {
|
|
const accessKey = randomBytes(32).toString('base64url');
|
|
clearPresentationState(database, showId);
|
|
database
|
|
.prepare(
|
|
`INSERT INTO presentation_channels
|
|
(id, name, access_key, key_hash, show_id, revision, created_at_utc, updated_at_utc)
|
|
VALUES ('default', 'Standardausgabe', ?, ?, ?, 1, ?, ?)`
|
|
)
|
|
.run(accessKey, hashToken(accessKey), showId, now, now);
|
|
channel = { access_key: accessKey, show_id: showId };
|
|
} else if (channel.show_id !== showId) {
|
|
clearPresentationState(database, showId);
|
|
database
|
|
.prepare(
|
|
`UPDATE presentation_channels SET show_id = ?, revision = revision + 1,
|
|
updated_at_utc = ? WHERE id = 'default'`
|
|
)
|
|
.run(showId, now);
|
|
}
|
|
return channel.access_key;
|
|
})();
|
|
}
|
|
|
|
function clearPresentationState(database: Database.Database, showId: string) {
|
|
database
|
|
.prepare(
|
|
`UPDATE show_live_states SET presentation_usage_id = NULL,
|
|
presentation_revision = presentation_revision + 1, updated_at_utc = ?
|
|
WHERE show_id = ? AND presentation_usage_id IS NOT NULL`
|
|
)
|
|
.run(nowIso(), showId);
|
|
}
|
|
|
|
export function clearPresentationChannel() {
|
|
const now = nowIso();
|
|
getDatabase().transaction(() => {
|
|
const database = getDatabase();
|
|
const channel = database
|
|
.prepare("SELECT show_id FROM presentation_channels WHERE id = 'default'")
|
|
.get() as { show_id: string | null } | undefined;
|
|
if (!channel) throw new Error('NOT_FOUND');
|
|
if (channel.show_id) clearPresentationState(database, channel.show_id);
|
|
database
|
|
.prepare(
|
|
`UPDATE presentation_channels SET show_id = NULL, revision = revision + 1,
|
|
updated_at_utc = ? WHERE id = 'default'`
|
|
)
|
|
.run(now);
|
|
})();
|
|
}
|
|
|
|
export function rotatePresentationChannelKey(showId: string) {
|
|
issuePresentationAccess(showId);
|
|
const accessKey = randomBytes(32).toString('base64url');
|
|
const now = nowIso();
|
|
getDatabase()
|
|
.prepare(
|
|
`UPDATE presentation_channels SET access_key = ?, key_hash = ?, revision = revision + 1,
|
|
updated_at_utc = ? WHERE id = 'default'`
|
|
)
|
|
.run(accessKey, hashToken(accessKey), now);
|
|
return accessKey;
|
|
}
|
|
|
|
export function presentationChannelAccess(channelId: string, accessKey: string) {
|
|
if (!channelId || !accessKey || accessKey.length > 200) return false;
|
|
return Boolean(
|
|
getDatabase()
|
|
.prepare('SELECT 1 FROM presentation_channels WHERE id = ? AND key_hash = ?')
|
|
.get(channelId, hashToken(accessKey))
|
|
);
|
|
}
|
|
|
|
function presentationShowId(database: Database.Database, token: string) {
|
|
if (!token || token.length > 200) return null;
|
|
const channel = database
|
|
.prepare('SELECT show_id FROM presentation_channels WHERE key_hash = ?')
|
|
.get(hashToken(token)) as { show_id: string | null } | undefined;
|
|
if (channel) return channel.show_id;
|
|
const row = database
|
|
.prepare(
|
|
`SELECT show_id FROM presentation_access_tokens
|
|
WHERE token_hash = ? AND revoked_at_utc IS NULL`
|
|
)
|
|
.get(hashToken(token)) as { show_id: string } | undefined;
|
|
return row?.show_id ?? null;
|
|
}
|
|
|
|
export function getPresentationChannelView(channelId: string): PresentationView | null {
|
|
const channel = getDatabase()
|
|
.prepare('SELECT show_id, revision FROM presentation_channels WHERE id = ?')
|
|
.get(channelId) as { show_id: string | null; revision: number } | undefined;
|
|
if (!channel) return null;
|
|
if (!channel.show_id) return { revision: channel.revision * 1_000_000_000, content: null };
|
|
const view = getPresentationViewForShow(channel.show_id);
|
|
return { ...view, revision: channel.revision * 1_000_000_000 + view.revision };
|
|
}
|
|
|
|
export function getPresentationView(token: string): PresentationView | null {
|
|
const database = getDatabase();
|
|
const showId = presentationShowId(database, token);
|
|
if (!showId) return null;
|
|
return getPresentationViewForShow(showId);
|
|
}
|
|
|
|
function getPresentationViewForShow(showId: string): PresentationView {
|
|
const database = getDatabase();
|
|
const state = ensureLiveState(database, showId, nowIso());
|
|
if (!state.presentation_usage_id) return { revision: state.presentation_revision, content: null };
|
|
const usage = database
|
|
.prepare(
|
|
`SELECT u.title_snapshot, u.output_title_snapshot, u.presentation_snapshot,
|
|
u.presentation_mode_snapshot, u.presentation_source_label_snapshot,
|
|
u.presentation_source_url_snapshot, u.presentation_source_timecode_snapshot,
|
|
u.presentation_title_meta_snapshot, u.presentation_description_snapshot,
|
|
u.presentation_image_url_snapshot, u.presentation_site_name_snapshot,
|
|
u.presentation_provider_snapshot, u.presentation_provider_id_snapshot
|
|
FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
|
|
WHERE u.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0`
|
|
)
|
|
.get(state.presentation_usage_id, showId) as
|
|
| {
|
|
title_snapshot: string;
|
|
output_title_snapshot: string;
|
|
presentation_snapshot: string;
|
|
presentation_mode_snapshot: PresentationContent['mode'];
|
|
presentation_source_label_snapshot: string;
|
|
presentation_source_url_snapshot: string;
|
|
presentation_source_timecode_snapshot: number | null;
|
|
presentation_title_meta_snapshot: string;
|
|
presentation_description_snapshot: string;
|
|
presentation_image_url_snapshot: string;
|
|
presentation_site_name_snapshot: string;
|
|
presentation_provider_snapshot: PresentationContent['provider'];
|
|
presentation_provider_id_snapshot: string;
|
|
}
|
|
| undefined;
|
|
if (!usage) return { revision: state.presentation_revision, content: null };
|
|
return {
|
|
revision: state.presentation_revision,
|
|
content: {
|
|
mode: usage.presentation_mode_snapshot,
|
|
topics: (
|
|
database
|
|
.prepare('SELECT name FROM usage_topic_snapshots WHERE usage_id = ? ORDER BY position')
|
|
.all(state.presentation_usage_id) as { name: string }[]
|
|
).map((topic) => topic.name),
|
|
title: usage.output_title_snapshot || usage.title_snapshot,
|
|
html: renderMarkdown(usage.presentation_snapshot),
|
|
source: usage.presentation_source_url_snapshot
|
|
? {
|
|
label: usage.presentation_source_label_snapshot,
|
|
url: usage.presentation_source_url_snapshot,
|
|
timecodeSeconds: usage.presentation_source_timecode_snapshot
|
|
}
|
|
: null,
|
|
previewTitle: usage.presentation_title_meta_snapshot,
|
|
description: usage.presentation_description_snapshot,
|
|
imageUrl: usage.presentation_image_url_snapshot,
|
|
siteName: usage.presentation_site_name_snapshot,
|
|
provider: usage.presentation_provider_snapshot,
|
|
providerId: usage.presentation_provider_id_snapshot,
|
|
embedUrl: buildEmbedUrl(
|
|
usage.presentation_provider_snapshot,
|
|
usage.presentation_provider_id_snapshot,
|
|
usage.presentation_source_timecode_snapshot
|
|
),
|
|
sources: [],
|
|
images: (
|
|
database
|
|
.prepare(
|
|
`SELECT id, alt_text FROM usage_media_snapshots
|
|
WHERE usage_id = ? AND is_presentation = 1`
|
|
)
|
|
.all(state.presentation_usage_id) as { id: string; alt_text: string }[]
|
|
).map((media) => ({ id: media.id, altText: media.alt_text }))
|
|
}
|
|
};
|
|
}
|
|
|
|
export async function getPresentationPreviewImage(token: string) {
|
|
const view = getPresentationView(token);
|
|
if (!view?.content?.imageUrl || view.content.mode === 'text') return null;
|
|
try {
|
|
return await fetchPresentationImage(view.content.imageUrl);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export async function getPresentationMedia(
|
|
token: string,
|
|
snapshotId: string
|
|
): Promise<{ data: Buffer; mimeType: string; byteSize: number; altText: string } | null> {
|
|
const database = getDatabase();
|
|
const showId = presentationShowId(database, token);
|
|
if (!showId || !snapshotId) return null;
|
|
const media = database
|
|
.prepare(
|
|
`SELECT pm.storage_name, pm.mime_type, pm.byte_size, ums.alt_text
|
|
FROM show_live_states state
|
|
JOIN usage_media_snapshots ums ON ums.usage_id = state.presentation_usage_id
|
|
JOIN piece_usages u ON u.id = ums.usage_id
|
|
JOIN show_sections s ON s.id = u.show_section_id
|
|
JOIN piece_media pm ON pm.id = ums.original_media_id
|
|
WHERE state.show_id = ? AND s.show_id = state.show_id
|
|
AND s.is_reserve_bank = 0 AND ums.id = ? AND ums.is_presentation = 1`
|
|
)
|
|
.get(showId, snapshotId) as
|
|
{ storage_name: string; mime_type: string; byte_size: number; alt_text: string } | undefined;
|
|
if (!media) return null;
|
|
try {
|
|
return {
|
|
data: await readFile(path.join(getServerPaths().uploads, media.storage_name)),
|
|
mimeType: media.mime_type,
|
|
byteSize: media.byte_size,
|
|
altText: media.alt_text
|
|
};
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|