1152 lines
36 KiB
TypeScript
1152 lines
36 KiB
TypeScript
import { z } from 'zod'
|
|
import { TRPCError } from '@trpc/server'
|
|
import { Prisma, type PrismaClient, type LiveProgressCursor } from '@prisma/client'
|
|
import { router, protectedProcedure, adminProcedure, audienceProcedure } from '../trpc'
|
|
import { logAudit } from '@/server/utils/audit'
|
|
|
|
// ─── Grand-finale phase machine helpers ─────────────────────────────────────
|
|
|
|
type TimingEntry = {
|
|
projectId: string
|
|
phase: 'PRESENTING' | 'QA'
|
|
startedAt: string
|
|
endedAt: string
|
|
configuredSeconds: number | null
|
|
overranSeconds: number
|
|
}
|
|
|
|
/**
|
|
* When leaving a timed phase (PRESENTING/QA), compute the actual elapsed time
|
|
* (pause-adjusted) and append it to the cursor's timing log. Overtime is
|
|
* recorded as fact — never as a penalty.
|
|
*/
|
|
function closedOutTiming(cursor: LiveProgressCursor, now: Date): Prisma.InputJsonValue | undefined {
|
|
if (!cursor.phaseStartedAt || !cursor.activeProjectId) return undefined
|
|
if (cursor.projectPhase !== 'PRESENTING' && cursor.projectPhase !== 'QA') return undefined
|
|
const end = cursor.phasePausedAt ?? now
|
|
const elapsedSec = Math.max(
|
|
0,
|
|
Math.floor((end.getTime() - cursor.phaseStartedAt.getTime() - cursor.phasePausedAccumMs) / 1000)
|
|
)
|
|
const entry: TimingEntry = {
|
|
projectId: cursor.activeProjectId,
|
|
phase: cursor.projectPhase,
|
|
startedAt: cursor.phaseStartedAt.toISOString(),
|
|
endedAt: now.toISOString(),
|
|
configuredSeconds: cursor.phaseDurationSeconds,
|
|
overranSeconds:
|
|
cursor.phaseDurationSeconds == null
|
|
? 0
|
|
: Math.max(0, elapsedSec - cursor.phaseDurationSeconds),
|
|
}
|
|
const log = Array.isArray(cursor.timingLogJson) ? (cursor.timingLogJson as unknown as TimingEntry[]) : []
|
|
return [...log, entry] as unknown as Prisma.InputJsonValue
|
|
}
|
|
|
|
async function getRoundCeremonyConfig(prisma: PrismaClient, roundId: string) {
|
|
const round = await prisma.round.findUniqueOrThrow({ where: { id: roundId } })
|
|
const cfg = (round.configJson as Record<string, unknown>) ?? {}
|
|
return {
|
|
presentationSeconds:
|
|
typeof cfg.presentationDurationMinutes === 'number'
|
|
? cfg.presentationDurationMinutes * 60
|
|
: 300,
|
|
qaSeconds: typeof cfg.qaDurationMinutes === 'number' ? cfg.qaDurationMinutes * 60 : 300,
|
|
projectOrder: (cfg.projectOrder as string[]) ?? [],
|
|
}
|
|
}
|
|
|
|
export const liveRouter = router({
|
|
/**
|
|
* Start a live presentation session for a stage
|
|
*/
|
|
start: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
projectOrder: z.array(z.string()).min(1), // Ordered project IDs
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
|
|
if (round.status !== 'ROUND_ACTIVE') {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Round must be ACTIVE to start a live session',
|
|
})
|
|
}
|
|
|
|
// Check for existing active cursor
|
|
const existingCursor = await ctx.prisma.liveProgressCursor.findUnique({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
if (existingCursor) {
|
|
throw new TRPCError({
|
|
code: 'CONFLICT',
|
|
message: 'A live session already exists for this round. Use jump/reorder to modify it.',
|
|
})
|
|
}
|
|
|
|
// Verify all projects exist
|
|
const projects = await ctx.prisma.project.findMany({
|
|
where: { id: { in: input.projectOrder } },
|
|
select: { id: true },
|
|
})
|
|
if (projects.length !== input.projectOrder.length) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: 'Some project IDs are invalid',
|
|
})
|
|
}
|
|
|
|
const cursor = await ctx.prisma.$transaction(async (tx) => {
|
|
// Store the project order in round config
|
|
await tx.round.update({
|
|
where: { id: input.roundId },
|
|
data: {
|
|
configJson: {
|
|
...(round.configJson as Record<string, unknown> ?? {}),
|
|
projectOrder: input.projectOrder,
|
|
} as Prisma.InputJsonValue,
|
|
},
|
|
})
|
|
|
|
const created = await tx.liveProgressCursor.create({
|
|
data: {
|
|
roundId: input.roundId,
|
|
activeProjectId: input.projectOrder[0],
|
|
activeOrderIndex: 0,
|
|
isPaused: false,
|
|
},
|
|
})
|
|
|
|
return created
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the session start
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_SESSION_STARTED',
|
|
entityType: 'Round',
|
|
entityId: input.roundId,
|
|
detailsJson: {
|
|
sessionId: cursor.sessionId,
|
|
projectCount: input.projectOrder.length,
|
|
firstProjectId: input.projectOrder[0],
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return cursor
|
|
}),
|
|
|
|
/**
|
|
* Set the active project in the live session
|
|
*/
|
|
setActiveProject: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
projectId: z.string(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
// Get project order from round config
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
const config = (round.configJson as Record<string, unknown>) ?? {}
|
|
const projectOrder = (config.projectOrder as string[]) ?? []
|
|
|
|
const index = projectOrder.indexOf(input.projectId)
|
|
if (index === -1) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: 'Project is not in the session order',
|
|
})
|
|
}
|
|
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
activeProjectId: input.projectId,
|
|
activeOrderIndex: index,
|
|
},
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the project set
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_ACTIVE_PROJECT_SET',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: {
|
|
projectId: input.projectId,
|
|
orderIndex: index,
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Jump to a specific index in the project order
|
|
*/
|
|
jump: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
index: z.number().int().min(0),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
const config = (round.configJson as Record<string, unknown>) ?? {}
|
|
const projectOrder = (config.projectOrder as string[]) ?? []
|
|
|
|
if (input.index >= projectOrder.length) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: `Index ${input.index} is out of range (0-${projectOrder.length - 1})`,
|
|
})
|
|
}
|
|
|
|
const targetProjectId = projectOrder[input.index]
|
|
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
activeProjectId: targetProjectId,
|
|
activeOrderIndex: input.index,
|
|
},
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the jump
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_JUMP',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: {
|
|
fromIndex: cursor.activeOrderIndex,
|
|
toIndex: input.index,
|
|
projectId: targetProjectId,
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Reorder the project presentation queue
|
|
*/
|
|
reorder: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
projectOrder: z.array(z.string()).min(1),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
// Update config with new order
|
|
const updated = await ctx.prisma.$transaction(async (tx) => {
|
|
await tx.round.update({
|
|
where: { id: input.roundId },
|
|
data: {
|
|
configJson: {
|
|
...(round.configJson as Record<string, unknown> ?? {}),
|
|
projectOrder: input.projectOrder,
|
|
} as Prisma.InputJsonValue,
|
|
},
|
|
})
|
|
|
|
// Recalculate active index
|
|
const newIndex = cursor.activeProjectId
|
|
? input.projectOrder.indexOf(cursor.activeProjectId)
|
|
: 0
|
|
|
|
const updatedCursor = await tx.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
activeOrderIndex: Math.max(0, newIndex),
|
|
},
|
|
})
|
|
|
|
return updatedCursor
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the reorder
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_REORDER',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: {
|
|
projectCount: input.projectOrder.length,
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Pause the live session
|
|
*/
|
|
pause: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
if (cursor.isPaused) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Session is already paused',
|
|
})
|
|
}
|
|
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: { isPaused: true },
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the pause
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PAUSED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { activeProjectId: cursor.activeProjectId },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Resume the live session
|
|
*/
|
|
resume: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
if (!cursor.isPaused) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Session is not paused',
|
|
})
|
|
}
|
|
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: { isPaused: false },
|
|
})
|
|
|
|
// Audit outside transaction so failures don't roll back the resume
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_RESUMED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { activeProjectId: cursor.activeProjectId },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return updated
|
|
}),
|
|
|
|
// ───────────────────────────────────────────────────────────────────────────
|
|
// Grand-finale phase machine (ON_DECK → PRESENTING → QA → SCORING)
|
|
// ───────────────────────────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Put a project on every screen as "Up next" — the grace period before the
|
|
* presentation actually starts. Clears any timer and override slide.
|
|
*/
|
|
sendToScreens: adminProcedure
|
|
.input(z.object({ roundId: z.string(), projectId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
const { projectOrder } = await getRoundCeremonyConfig(ctx.prisma, input.roundId)
|
|
const index = projectOrder.indexOf(input.projectId)
|
|
if (index === -1) {
|
|
throw new TRPCError({ code: 'BAD_REQUEST', message: 'Project is not in the session order' })
|
|
}
|
|
const now = new Date()
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
activeProjectId: input.projectId,
|
|
activeOrderIndex: index,
|
|
projectPhase: 'ON_DECK',
|
|
phaseStartedAt: null,
|
|
phaseDurationSeconds: null,
|
|
phasePausedAt: null,
|
|
phasePausedAccumMs: 0,
|
|
overrideSlide: null,
|
|
...(closedOutTiming(cursor, now) !== undefined
|
|
? { timingLogJson: closedOutTiming(cursor, now) }
|
|
: {}),
|
|
},
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_SEND_TO_SCREENS',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { projectId: input.projectId, orderIndex: index },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Start the presentation timer for the on-deck project.
|
|
*/
|
|
startPresentation: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
durationSeconds: z.number().int().min(10).max(7200).optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
if (!cursor.activeProjectId) {
|
|
throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'No project is on screen' })
|
|
}
|
|
const cfg = await getRoundCeremonyConfig(ctx.prisma, input.roundId)
|
|
const now = new Date()
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
projectPhase: 'PRESENTING',
|
|
phaseStartedAt: now,
|
|
phaseDurationSeconds: input.durationSeconds ?? cfg.presentationSeconds,
|
|
phasePausedAt: null,
|
|
phasePausedAccumMs: 0,
|
|
...(closedOutTiming(cursor, now) !== undefined
|
|
? { timingLogJson: closedOutTiming(cursor, now) }
|
|
: {}),
|
|
},
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PHASE_STARTED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { phase: 'PRESENTING', projectId: cursor.activeProjectId, durationSeconds: updated.phaseDurationSeconds },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Close out the presentation (logging overtime) and start the Q&A timer.
|
|
*/
|
|
startQA: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
durationSeconds: z.number().int().min(10).max(7200).optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
if (!cursor.activeProjectId) {
|
|
throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'No project is on screen' })
|
|
}
|
|
const cfg = await getRoundCeremonyConfig(ctx.prisma, input.roundId)
|
|
const now = new Date()
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
projectPhase: 'QA',
|
|
phaseStartedAt: now,
|
|
phaseDurationSeconds: input.durationSeconds ?? cfg.qaSeconds,
|
|
phasePausedAt: null,
|
|
phasePausedAccumMs: 0,
|
|
...(closedOutTiming(cursor, now) !== undefined
|
|
? { timingLogJson: closedOutTiming(cursor, now) }
|
|
: {}),
|
|
},
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PHASE_STARTED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { phase: 'QA', projectId: cursor.activeProjectId, durationSeconds: updated.phaseDurationSeconds },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Close out Q&A (logging overtime) and open jury scoring (no timer).
|
|
*/
|
|
openScoring: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
const now = new Date()
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
projectPhase: 'SCORING',
|
|
phaseStartedAt: null,
|
|
phaseDurationSeconds: null,
|
|
phasePausedAt: null,
|
|
phasePausedAccumMs: 0,
|
|
...(closedOutTiming(cursor, now) !== undefined
|
|
? { timingLogJson: closedOutTiming(cursor, now) }
|
|
: {}),
|
|
},
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PHASE_STARTED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { phase: 'SCORING', projectId: cursor.activeProjectId },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Pause the running phase timer (e.g. technical difficulties).
|
|
*/
|
|
pausePhase: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
if (!cursor.phaseStartedAt || cursor.phasePausedAt) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: cursor.phasePausedAt ? 'Timer is already paused' : 'No timer is running',
|
|
})
|
|
}
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: { phasePausedAt: new Date() },
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PHASE_PAUSED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { phase: cursor.projectPhase, projectId: cursor.activeProjectId },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Resume the paused phase timer, folding paused time into the accumulator.
|
|
*/
|
|
resumePhase: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
if (!cursor.phasePausedAt) {
|
|
throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Timer is not paused' })
|
|
}
|
|
const now = new Date()
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: {
|
|
phasePausedAccumMs:
|
|
cursor.phasePausedAccumMs + (now.getTime() - cursor.phasePausedAt.getTime()),
|
|
phasePausedAt: null,
|
|
},
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_PHASE_RESUMED',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { phase: cursor.projectPhase, projectId: cursor.activeProjectId },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Force a static slide on the big screen (or clear it).
|
|
*/
|
|
setOverrideSlide: adminProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
slide: z.enum(['welcome', 'break', 'deliberation', 'thanks']).nullable(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
const updated = await ctx.prisma.liveProgressCursor.update({
|
|
where: { id: cursor.id },
|
|
data: { overrideSlide: input.slide },
|
|
})
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'LIVE_OVERRIDE_SLIDE',
|
|
entityType: 'LiveProgressCursor',
|
|
entityId: cursor.id,
|
|
detailsJson: { slide: input.slide },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
return updated
|
|
}),
|
|
|
|
/**
|
|
* Persisted per-juror per-project ceremony notes (autosaved by the UI;
|
|
* resurfaced during deliberation).
|
|
*/
|
|
saveNote: protectedProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
projectId: z.string(),
|
|
content: z.string().max(20_000),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
return ctx.prisma.liveNote.upsert({
|
|
where: {
|
|
roundId_projectId_userId: {
|
|
roundId: input.roundId,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
},
|
|
},
|
|
create: {
|
|
roundId: input.roundId,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
content: input.content,
|
|
},
|
|
update: { content: input.content },
|
|
})
|
|
}),
|
|
|
|
getMyNotes: protectedProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
return ctx.prisma.liveNote.findMany({
|
|
where: { roundId: input.roundId, userId: ctx.user.id },
|
|
orderBy: { updatedAt: 'desc' },
|
|
})
|
|
}),
|
|
|
|
/**
|
|
* Get current cursor state (for all users, including audience)
|
|
*/
|
|
getCursor: protectedProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUnique({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
if (!cursor) {
|
|
return null
|
|
}
|
|
|
|
// Get round config for project order
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
const config = (round.configJson as Record<string, unknown>) ?? {}
|
|
const projectOrder = (config.projectOrder as string[]) ?? []
|
|
|
|
// Get current project details
|
|
let activeProject = null
|
|
if (cursor.activeProjectId) {
|
|
activeProject = await ctx.prisma.project.findUnique({
|
|
where: { id: cursor.activeProjectId },
|
|
select: {
|
|
id: true,
|
|
title: true,
|
|
teamName: true,
|
|
description: true,
|
|
tags: true,
|
|
competitionCategory: true,
|
|
},
|
|
})
|
|
}
|
|
|
|
// Full run order with categories (for the admin run-order list and
|
|
// category grouping on every surface)
|
|
const orderProjects = await ctx.prisma.project.findMany({
|
|
where: { id: { in: projectOrder } },
|
|
select: { id: true, title: true, teamName: true, competitionCategory: true },
|
|
})
|
|
const orderById = new Map(orderProjects.map((p) => [p.id, p]))
|
|
const orderedProjects = projectOrder
|
|
.map((id) => orderById.get(id))
|
|
.filter((p): p is NonNullable<typeof p> => !!p)
|
|
|
|
// Get open cohorts for this round (if any)
|
|
const openCohorts = await ctx.prisma.cohort.findMany({
|
|
where: { roundId: input.roundId, isOpen: true },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
votingMode: true,
|
|
windowCloseAt: true,
|
|
},
|
|
})
|
|
|
|
return {
|
|
...cursor,
|
|
activeProject,
|
|
projectOrder,
|
|
orderedProjects,
|
|
totalProjects: projectOrder.length,
|
|
openCohorts,
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Cast a vote during a live session (audience or jury)
|
|
* Checks window is open and deduplicates votes
|
|
*/
|
|
castVote: audienceProcedure
|
|
.input(
|
|
z.object({
|
|
roundId: z.string(),
|
|
projectId: z.string(),
|
|
score: z.number().int().min(1).max(10),
|
|
criterionScoresJson: z.record(z.number()).optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
// Verify live session exists and is not paused
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUniqueOrThrow({
|
|
where: { roundId: input.roundId },
|
|
})
|
|
|
|
if (cursor.isPaused) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Voting is paused',
|
|
})
|
|
}
|
|
|
|
// Check if there's an open cohort containing this project
|
|
const openCohort = await ctx.prisma.cohort.findFirst({
|
|
where: {
|
|
roundId: input.roundId,
|
|
isOpen: true,
|
|
projects: { some: { projectId: input.projectId } },
|
|
},
|
|
})
|
|
|
|
// Check voting window if cohort has time limits
|
|
if (openCohort?.windowCloseAt) {
|
|
const now = new Date()
|
|
if (now > openCohort.windowCloseAt) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Voting window has closed',
|
|
})
|
|
}
|
|
}
|
|
|
|
// Find the LiveVotingSession linked to this round
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
select: { competition: { select: { programId: true } } },
|
|
})
|
|
|
|
// Find or check existing LiveVotingSession for this round
|
|
const session = await ctx.prisma.liveVotingSession.findFirst({
|
|
where: {
|
|
round: { competition: { programId: round.competition.programId } },
|
|
status: 'IN_PROGRESS',
|
|
},
|
|
})
|
|
|
|
if (!session) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'No active voting session found',
|
|
})
|
|
}
|
|
|
|
// Deduplicate: check if user already voted on this project in this session
|
|
const existingVote = await ctx.prisma.liveVote.findUnique({
|
|
where: {
|
|
sessionId_projectId_userId: {
|
|
sessionId: session.id,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
},
|
|
},
|
|
})
|
|
|
|
if (existingVote) {
|
|
// Update existing vote
|
|
const updated = await ctx.prisma.liveVote.update({
|
|
where: { id: existingVote.id },
|
|
data: {
|
|
score: input.score,
|
|
criterionScoresJson: input.criterionScoresJson
|
|
? (input.criterionScoresJson as Prisma.InputJsonValue)
|
|
: undefined,
|
|
votedAt: new Date(),
|
|
},
|
|
})
|
|
|
|
return { vote: updated, wasUpdate: true }
|
|
}
|
|
|
|
// Create new vote
|
|
const vote = await ctx.prisma.liveVote.create({
|
|
data: {
|
|
sessionId: session.id,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
score: input.score,
|
|
isAudienceVote: !['JURY_MEMBER', 'SUPER_ADMIN', 'PROGRAM_ADMIN'].includes(
|
|
ctx.user.role
|
|
),
|
|
criterionScoresJson: input.criterionScoresJson
|
|
? (input.criterionScoresJson as Prisma.InputJsonValue)
|
|
: undefined,
|
|
},
|
|
})
|
|
|
|
return { vote, wasUpdate: false }
|
|
}),
|
|
|
|
// =========================================================================
|
|
// Phase 4: Audience-native procedures
|
|
// =========================================================================
|
|
|
|
/**
|
|
* Get audience context for a live session (public-facing via sessionId)
|
|
*/
|
|
getAudienceContext: protectedProcedure
|
|
.input(z.object({ sessionId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUnique({
|
|
where: { sessionId: input.sessionId },
|
|
})
|
|
|
|
if (!cursor) {
|
|
throw new TRPCError({
|
|
code: 'NOT_FOUND',
|
|
message: 'Live session not found',
|
|
})
|
|
}
|
|
|
|
// Get round info
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: cursor.roundId },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
status: true,
|
|
configJson: true,
|
|
},
|
|
})
|
|
|
|
// Get active project
|
|
let activeProject = null
|
|
if (cursor.activeProjectId) {
|
|
activeProject = await ctx.prisma.project.findUnique({
|
|
where: { id: cursor.activeProjectId },
|
|
select: {
|
|
id: true,
|
|
title: true,
|
|
teamName: true,
|
|
description: true,
|
|
tags: true,
|
|
country: true,
|
|
},
|
|
})
|
|
}
|
|
|
|
// Get open cohorts
|
|
const openCohorts = await ctx.prisma.cohort.findMany({
|
|
where: { roundId: cursor.roundId, isOpen: true },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
votingMode: true,
|
|
windowOpenAt: true,
|
|
windowCloseAt: true,
|
|
projects: {
|
|
select: { projectId: true },
|
|
},
|
|
},
|
|
})
|
|
|
|
const config = (round.configJson as Record<string, unknown>) ?? {}
|
|
const projectOrder = (config.projectOrder as string[]) ?? []
|
|
|
|
const now = new Date()
|
|
const isWindowOpen = round.status === 'ROUND_ACTIVE'
|
|
|
|
// Aggregate project scores from LiveVote for the scoreboard
|
|
// Find the active LiveVotingSession for this round's program
|
|
const votingSession = await ctx.prisma.liveVotingSession.findFirst({
|
|
where: {
|
|
round: { competition: { programId: round.id } },
|
|
status: 'IN_PROGRESS',
|
|
},
|
|
select: { id: true },
|
|
})
|
|
|
|
// Get all cohort project IDs for this stage
|
|
const allCohortProjectIds = openCohorts.flatMap((c) =>
|
|
c.projects.map((p) => p.projectId)
|
|
)
|
|
const uniqueProjectIds = [...new Set(allCohortProjectIds)]
|
|
|
|
let projectScores: Array<{
|
|
projectId: string
|
|
title: string
|
|
teamName: string | null
|
|
averageScore: number
|
|
voteCount: number
|
|
}> = []
|
|
|
|
if (votingSession && uniqueProjectIds.length > 0) {
|
|
// Get vote aggregates
|
|
const voteAggregates = await ctx.prisma.liveVote.groupBy({
|
|
by: ['projectId'],
|
|
where: {
|
|
sessionId: votingSession.id,
|
|
projectId: { in: uniqueProjectIds },
|
|
},
|
|
_avg: { score: true },
|
|
_count: { score: true },
|
|
})
|
|
|
|
// Get project details
|
|
const projects = await ctx.prisma.project.findMany({
|
|
where: { id: { in: uniqueProjectIds } },
|
|
select: { id: true, title: true, teamName: true },
|
|
})
|
|
|
|
const projectMap = new Map(projects.map((p) => [p.id, p]))
|
|
projectScores = voteAggregates.map((agg) => {
|
|
const project = projectMap.get(agg.projectId)
|
|
return {
|
|
projectId: agg.projectId,
|
|
title: project?.title ?? 'Unknown',
|
|
teamName: project?.teamName ?? null,
|
|
averageScore: agg._avg.score ?? 0,
|
|
voteCount: agg._count.score,
|
|
}
|
|
})
|
|
}
|
|
|
|
return {
|
|
cursor: {
|
|
sessionId: cursor.sessionId,
|
|
activeOrderIndex: cursor.activeOrderIndex,
|
|
isPaused: cursor.isPaused,
|
|
totalProjects: projectOrder.length,
|
|
},
|
|
activeProject,
|
|
openCohorts: openCohorts.map((c) => ({
|
|
id: c.id,
|
|
name: c.name,
|
|
votingMode: c.votingMode,
|
|
windowCloseAt: c.windowCloseAt,
|
|
projectIds: c.projects.map((p) => p.projectId),
|
|
})),
|
|
projectScores,
|
|
roundInfo: {
|
|
id: round.id,
|
|
name: round.name,
|
|
},
|
|
windowStatus: {
|
|
isOpen: true,
|
|
closesAt: null,
|
|
},
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Cast a vote in a stage-native live session
|
|
*/
|
|
castStageVote: audienceProcedure
|
|
.input(
|
|
z.object({
|
|
sessionId: z.string(),
|
|
projectId: z.string(),
|
|
score: z.number().int().min(1).max(10),
|
|
dedupeKey: z.string().optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
// Resolve cursor by sessionId
|
|
const cursor = await ctx.prisma.liveProgressCursor.findUnique({
|
|
where: { sessionId: input.sessionId },
|
|
})
|
|
|
|
if (!cursor) {
|
|
throw new TRPCError({
|
|
code: 'NOT_FOUND',
|
|
message: 'Live session not found',
|
|
})
|
|
}
|
|
|
|
if (cursor.isPaused) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Voting is paused',
|
|
})
|
|
}
|
|
|
|
// Check if there's an open cohort containing this project
|
|
const openCohort = await ctx.prisma.cohort.findFirst({
|
|
where: {
|
|
roundId: cursor.roundId,
|
|
isOpen: true,
|
|
projects: { some: { projectId: input.projectId } },
|
|
},
|
|
})
|
|
|
|
if (openCohort?.windowCloseAt) {
|
|
const now = new Date()
|
|
if (now > openCohort.windowCloseAt) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'Voting window has closed',
|
|
})
|
|
}
|
|
}
|
|
|
|
// Find an active LiveVotingSession
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: cursor.roundId },
|
|
select: { competition: { select: { programId: true } } },
|
|
})
|
|
|
|
const session = await ctx.prisma.liveVotingSession.findFirst({
|
|
where: {
|
|
round: { competition: { programId: round.competition.programId } },
|
|
status: 'IN_PROGRESS',
|
|
},
|
|
})
|
|
|
|
if (!session) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'No active voting session found',
|
|
})
|
|
}
|
|
|
|
// Deduplicate: sessionId + projectId + userId
|
|
const existingVote = await ctx.prisma.liveVote.findUnique({
|
|
where: {
|
|
sessionId_projectId_userId: {
|
|
sessionId: session.id,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
},
|
|
},
|
|
})
|
|
|
|
if (existingVote) {
|
|
const updated = await ctx.prisma.liveVote.update({
|
|
where: { id: existingVote.id },
|
|
data: {
|
|
score: input.score,
|
|
votedAt: new Date(),
|
|
},
|
|
})
|
|
return { vote: updated, wasUpdate: true }
|
|
}
|
|
|
|
const vote = await ctx.prisma.liveVote.create({
|
|
data: {
|
|
sessionId: session.id,
|
|
projectId: input.projectId,
|
|
userId: ctx.user.id,
|
|
score: input.score,
|
|
isAudienceVote: !['JURY_MEMBER', 'SUPER_ADMIN', 'PROGRAM_ADMIN'].includes(
|
|
ctx.user.role
|
|
),
|
|
},
|
|
})
|
|
|
|
return { vote, wasUpdate: false }
|
|
}),
|
|
})
|