624 lines
19 KiB
TypeScript
624 lines
19 KiB
TypeScript
import { createHash, randomBytes, randomUUID } from 'node:crypto';
|
|
import type Database from 'better-sqlite3';
|
|
import { getMediaFile } from './content.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 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;
|
|
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;
|
|
startedAtUtc: string | null;
|
|
updatedAtUtc: string;
|
|
presentationUsageId: string | null;
|
|
presentationRevision: number;
|
|
sections: LiveSection[];
|
|
reserve: LiveUsage[];
|
|
current: LiveUsage | null;
|
|
next: LiveUsage | null;
|
|
completedCount: number;
|
|
totalCount: number;
|
|
};
|
|
|
|
export type PresentationView = {
|
|
revision: number;
|
|
content: null | {
|
|
mode: PresentationContent['mode'];
|
|
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 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);
|
|
}
|
|
|
|
function executeCommand(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
action: string,
|
|
operation: (database: Database.Database, state: LiveStateRow, now: string) => void,
|
|
nowValue?: Date
|
|
) {
|
|
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 (show.status === 'completed') 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),
|
|
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));
|
|
return {
|
|
show: {
|
|
id: show.id,
|
|
title: show.title,
|
|
status: show.status,
|
|
revision: show.revision,
|
|
totalDurationSeconds: show.totalDurationSeconds
|
|
},
|
|
liveRevision: state.revision,
|
|
startedAtUtc: state.started_at_utc,
|
|
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
|
|
};
|
|
}
|
|
|
|
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', 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);
|
|
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) 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
|
|
);
|
|
}
|
|
|
|
function advanceCurrent(
|
|
showId: string,
|
|
commandId: string,
|
|
expectedRevision: number,
|
|
status: 'done' | 'skipped',
|
|
nowValue?: Date
|
|
) {
|
|
return executeCommand(
|
|
showId,
|
|
commandId,
|
|
expectedRevision,
|
|
status,
|
|
(database, state, now) => {
|
|
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
|
|
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) => {
|
|
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 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);
|
|
const token = randomBytes(32).toString('base64url');
|
|
database.transaction(() => {
|
|
database
|
|
.prepare(
|
|
'UPDATE presentation_access_tokens SET revoked_at_utc = ? WHERE show_id = ? AND revoked_at_utc IS NULL'
|
|
)
|
|
.run(now, showId);
|
|
database
|
|
.prepare(
|
|
`INSERT INTO presentation_access_tokens (id, show_id, token_hash, created_at_utc)
|
|
VALUES (?, ?, ?, ?)`
|
|
)
|
|
.run(randomUUID(), showId, hashToken(token), now);
|
|
})();
|
|
return token;
|
|
}
|
|
|
|
function presentationShowId(database: Database.Database, token: string) {
|
|
if (!token || token.length > 200) return null;
|
|
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 getPresentationView(token: string): PresentationView | null {
|
|
const database = getDatabase();
|
|
const showId = presentationShowId(database, token);
|
|
if (!showId) return null;
|
|
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.presentation_snapshot, u.original_piece_id,
|
|
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;
|
|
presentation_snapshot: string;
|
|
original_piece_id: string | null;
|
|
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 };
|
|
const sources =
|
|
usage.presentation_mode_snapshot === 'text' && usage.original_piece_id
|
|
? (database
|
|
.prepare(
|
|
`SELECT label, url, timecode_seconds AS timecodeSeconds
|
|
FROM piece_sources WHERE piece_id = ? ORDER BY position`
|
|
)
|
|
.all(usage.original_piece_id) as {
|
|
label: string;
|
|
url: string;
|
|
timecodeSeconds: number | null;
|
|
}[])
|
|
: [];
|
|
const images =
|
|
usage.presentation_mode_snapshot === 'text' && usage.original_piece_id
|
|
? (database
|
|
.prepare(
|
|
`SELECT id, alt_text AS altText FROM piece_media
|
|
WHERE piece_id = ? ORDER BY position`
|
|
)
|
|
.all(usage.original_piece_id) as { id: string; altText: string }[])
|
|
: [];
|
|
return {
|
|
revision: state.presentation_revision,
|
|
content: {
|
|
mode: usage.presentation_mode_snapshot,
|
|
title: 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
|
|
}
|
|
};
|
|
}
|
|
|
|
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, mediaId: string) {
|
|
const database = getDatabase();
|
|
const showId = presentationShowId(database, token);
|
|
if (!showId) return null;
|
|
const allowed = database
|
|
.prepare(
|
|
`SELECT 1 FROM show_live_states l
|
|
JOIN piece_usages u ON u.id = l.presentation_usage_id
|
|
JOIN show_sections s ON s.id = u.show_section_id
|
|
JOIN piece_media m ON m.piece_id = u.original_piece_id
|
|
WHERE l.show_id = ? AND s.show_id = ? AND m.id = ?`
|
|
)
|
|
.get(showId, showId, mediaId);
|
|
if (!allowed) return null;
|
|
return getMediaFile(mediaId);
|
|
}
|