1163 lines
44 KiB
TypeScript
1163 lines
44 KiB
TypeScript
|
import { z } from 'zod'
|
||
|
|
import { TRPCError } from '@trpc/server'
|
||
|
|
import { router, adminProcedure } from '../../trpc'
|
||
|
|
import { createNotification, createBulkNotifications, notifyAdmins, NotificationTypes } from '../../services/in-app-notification'
|
||
|
|
import { logAudit } from '@/server/utils/audit'
|
||
|
|
import { reassignAfterCOI, reassignDroppedJurorAssignments } from '../../services/juror-reassignment'
|
||
|
|
import { MOVABLE_EVAL_STATUSES, getCandidateJurors } from './shared'
|
||
|
|
|
||
|
|
export const assignmentRedistributionRouter = router({
|
||
|
|
reassignCOI: adminProcedure
|
||
|
|
.input(z.object({ assignmentId: z.string() }))
|
||
|
|
.mutation(async ({ ctx, input }) => {
|
||
|
|
const result = await reassignAfterCOI({
|
||
|
|
assignmentId: input.assignmentId,
|
||
|
|
auditUserId: ctx.user.id,
|
||
|
|
auditIp: ctx.ip,
|
||
|
|
auditUserAgent: ctx.userAgent,
|
||
|
|
})
|
||
|
|
|
||
|
|
if (!result) {
|
||
|
|
throw new TRPCError({
|
||
|
|
code: 'BAD_REQUEST',
|
||
|
|
message: 'No eligible juror found for reassignment. All jurors are either already assigned to this project, have a COI, or are at their assignment limit.',
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
return result
|
||
|
|
}),
|
||
|
|
|
||
|
|
reassignDroppedJuror: adminProcedure
|
||
|
|
.input(z.object({ roundId: z.string(), jurorId: z.string() }))
|
||
|
|
.mutation(async ({ ctx, input }) => {
|
||
|
|
return reassignDroppedJurorAssignments({
|
||
|
|
roundId: input.roundId,
|
||
|
|
droppedJurorId: input.jurorId,
|
||
|
|
auditUserId: ctx.user.id,
|
||
|
|
auditIp: ctx.ip,
|
||
|
|
auditUserAgent: ctx.userAgent,
|
||
|
|
})
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Redistribute all movable assignments from a juror to other jurors (without dropping them from the group).
|
||
|
|
* Uses the same greedy algorithm as reassignDroppedJuror but keeps the juror in the jury group.
|
||
|
|
* Prefers jurors who haven't finished all evaluations; as last resort uses completed jurors.
|
||
|
|
*/
|
||
|
|
redistributeJurorAssignments: adminProcedure
|
||
|
|
.input(z.object({ roundId: z.string(), jurorId: z.string() }))
|
||
|
|
.mutation(async ({ ctx, input }) => {
|
||
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
||
|
|
where: { id: input.roundId },
|
||
|
|
select: { id: true, name: true, configJson: true, juryGroupId: true, windowCloseAt: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const sourceJuror = await ctx.prisma.user.findUniqueOrThrow({
|
||
|
|
where: { id: input.jurorId },
|
||
|
|
select: { id: true, name: true, email: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const config = (round.configJson ?? {}) as Record<string, unknown>
|
||
|
|
const fallbackCap =
|
||
|
|
(config.maxLoadPerJuror as number) ??
|
||
|
|
(config.maxAssignmentsPerJuror as number) ??
|
||
|
|
20
|
||
|
|
|
||
|
|
const assignmentsToMove = await ctx.prisma.assignment.findMany({
|
||
|
|
where: {
|
||
|
|
roundId: input.roundId,
|
||
|
|
userId: input.jurorId,
|
||
|
|
OR: [
|
||
|
|
{ evaluation: null },
|
||
|
|
{ evaluation: { status: { in: [...MOVABLE_EVAL_STATUSES] } } },
|
||
|
|
],
|
||
|
|
},
|
||
|
|
select: {
|
||
|
|
id: true, projectId: true, juryGroupId: true, isRequired: true,
|
||
|
|
project: { select: { title: true } },
|
||
|
|
},
|
||
|
|
orderBy: { createdAt: 'asc' },
|
||
|
|
})
|
||
|
|
|
||
|
|
if (assignmentsToMove.length === 0) {
|
||
|
|
return { movedCount: 0, failedCount: 0, failedProjects: [] as string[] }
|
||
|
|
}
|
||
|
|
|
||
|
|
// Build candidate pool
|
||
|
|
const candidateJurors = await getCandidateJurors(
|
||
|
|
ctx.prisma,
|
||
|
|
input.roundId,
|
||
|
|
round.juryGroupId,
|
||
|
|
input.jurorId,
|
||
|
|
)
|
||
|
|
|
||
|
|
if (candidateJurors.length === 0) {
|
||
|
|
throw new TRPCError({ code: 'BAD_REQUEST', message: 'No active replacement jurors available' })
|
||
|
|
}
|
||
|
|
|
||
|
|
const candidateIds = candidateJurors.map((j) => j.id)
|
||
|
|
|
||
|
|
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: { roundId: input.roundId },
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const alreadyAssigned = new Set(existingAssignments.map((a) => `${a.userId}:${a.projectId}`))
|
||
|
|
const currentLoads = new Map<string, number>()
|
||
|
|
for (const a of existingAssignments) currentLoads.set(a.userId, (currentLoads.get(a.userId) ?? 0) + 1)
|
||
|
|
|
||
|
|
const coiRecords = await ctx.prisma.conflictOfInterest.findMany({
|
||
|
|
where: { assignment: { roundId: input.roundId }, hasConflict: true, userId: { in: candidateIds } },
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const coiPairs = new Set(coiRecords.map((c) => `${c.userId}:${c.projectId}`))
|
||
|
|
|
||
|
|
// Completed eval counts for "prefer not-finished" logic
|
||
|
|
const completedEvals = await ctx.prisma.evaluation.findMany({
|
||
|
|
where: { assignment: { roundId: input.roundId, userId: { in: candidateIds } }, status: 'SUBMITTED' },
|
||
|
|
select: { assignment: { select: { userId: true } } },
|
||
|
|
})
|
||
|
|
const completedCounts = new Map<string, number>()
|
||
|
|
for (const e of completedEvals) completedCounts.set(e.assignment.userId, (completedCounts.get(e.assignment.userId) ?? 0) + 1)
|
||
|
|
|
||
|
|
const caps = new Map<string, number>()
|
||
|
|
for (const j of candidateJurors) caps.set(j.id, j.maxAssignments ?? fallbackCap)
|
||
|
|
|
||
|
|
const plannedMoves: { assignmentId: string; projectId: string; projectTitle: string; newJurorId: string; juryGroupId: string | null; isRequired: boolean }[] = []
|
||
|
|
const failedProjects: string[] = []
|
||
|
|
|
||
|
|
for (const assignment of assignmentsToMove) {
|
||
|
|
// First pass: prefer jurors who haven't completed all evals
|
||
|
|
let eligible = candidateIds
|
||
|
|
.filter((jid) => !alreadyAssigned.has(`${jid}:${assignment.projectId}`))
|
||
|
|
.filter((jid) => !coiPairs.has(`${jid}:${assignment.projectId}`))
|
||
|
|
.filter((jid) => (currentLoads.get(jid) ?? 0) < (caps.get(jid) ?? fallbackCap))
|
||
|
|
|
||
|
|
// Sort: prefer not-all-completed, then lowest load
|
||
|
|
eligible.sort((a, b) => {
|
||
|
|
const loadA = currentLoads.get(a) ?? 0
|
||
|
|
const loadB = currentLoads.get(b) ?? 0
|
||
|
|
const compA = completedCounts.get(a) ?? 0
|
||
|
|
const compB = completedCounts.get(b) ?? 0
|
||
|
|
const doneA = loadA > 0 && compA === loadA ? 1 : 0
|
||
|
|
const doneB = loadB > 0 && compB === loadB ? 1 : 0
|
||
|
|
if (doneA !== doneB) return doneA - doneB
|
||
|
|
return loadA - loadB
|
||
|
|
})
|
||
|
|
|
||
|
|
if (eligible.length === 0) {
|
||
|
|
failedProjects.push(assignment.project.title)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
const selectedId = eligible[0]
|
||
|
|
plannedMoves.push({
|
||
|
|
assignmentId: assignment.id, projectId: assignment.projectId,
|
||
|
|
projectTitle: assignment.project.title, newJurorId: selectedId,
|
||
|
|
juryGroupId: assignment.juryGroupId ?? round.juryGroupId, isRequired: assignment.isRequired,
|
||
|
|
})
|
||
|
|
alreadyAssigned.add(`${selectedId}:${assignment.projectId}`)
|
||
|
|
currentLoads.set(selectedId, (currentLoads.get(selectedId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Execute in transaction
|
||
|
|
const actualMoves: typeof plannedMoves = []
|
||
|
|
if (plannedMoves.length > 0) {
|
||
|
|
await ctx.prisma.$transaction(async (tx) => {
|
||
|
|
for (const move of plannedMoves) {
|
||
|
|
const deleted = await tx.assignment.deleteMany({
|
||
|
|
where: {
|
||
|
|
id: move.assignmentId, userId: input.jurorId,
|
||
|
|
OR: [{ evaluation: null }, { evaluation: { status: { in: [...MOVABLE_EVAL_STATUSES] } } }],
|
||
|
|
},
|
||
|
|
})
|
||
|
|
if (deleted.count === 0) { failedProjects.push(move.projectTitle); continue }
|
||
|
|
await tx.assignment.create({
|
||
|
|
data: {
|
||
|
|
roundId: input.roundId, projectId: move.projectId, userId: move.newJurorId,
|
||
|
|
juryGroupId: move.juryGroupId ?? undefined, isRequired: move.isRequired,
|
||
|
|
method: 'MANUAL', createdBy: ctx.user.id,
|
||
|
|
},
|
||
|
|
})
|
||
|
|
actualMoves.push(move)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// Send MANUAL_REASSIGNED emails per destination juror
|
||
|
|
if (actualMoves.length > 0) {
|
||
|
|
const destProjectNames: Record<string, string[]> = {}
|
||
|
|
for (const move of actualMoves) {
|
||
|
|
if (!destProjectNames[move.newJurorId]) destProjectNames[move.newJurorId] = []
|
||
|
|
destProjectNames[move.newJurorId].push(move.projectTitle)
|
||
|
|
}
|
||
|
|
|
||
|
|
const deadline = round.windowCloseAt
|
||
|
|
? new Intl.DateTimeFormat('en-GB', { dateStyle: 'full', timeStyle: 'short', timeZone: 'Europe/Paris' }).format(round.windowCloseAt)
|
||
|
|
: undefined
|
||
|
|
|
||
|
|
for (const [jurorId, projectNames] of Object.entries(destProjectNames)) {
|
||
|
|
const count = projectNames.length
|
||
|
|
await createNotification({
|
||
|
|
userId: jurorId,
|
||
|
|
type: NotificationTypes.MANUAL_REASSIGNED,
|
||
|
|
title: count === 1 ? 'Project Reassigned to You' : `${count} Projects Reassigned to You`,
|
||
|
|
message: count === 1
|
||
|
|
? `The project "${projectNames[0]}" has been reassigned to you for evaluation in ${round.name}.`
|
||
|
|
: `${count} projects have been reassigned to you for evaluation in ${round.name}: ${projectNames.join(', ')}.`,
|
||
|
|
linkUrl: `/jury/competitions`,
|
||
|
|
linkLabel: 'View Assignments',
|
||
|
|
metadata: { roundId: round.id, roundName: round.name, projectNames, deadline, reason: 'admin_redistribute' },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
const sourceName = sourceJuror.name || sourceJuror.email
|
||
|
|
const candidateMeta = new Map(candidateJurors.map((j) => [j.id, j]))
|
||
|
|
const topReceivers = Object.entries(destProjectNames)
|
||
|
|
.map(([jid, ps]) => { const j = candidateMeta.get(jid); return `${j?.name || j?.email || jid} (${ps.length})` })
|
||
|
|
.join(', ')
|
||
|
|
|
||
|
|
await notifyAdmins({
|
||
|
|
type: NotificationTypes.EVALUATION_MILESTONE,
|
||
|
|
title: 'Assignment Redistribution',
|
||
|
|
message: `Redistributed ${actualMoves.length} project(s) from ${sourceName} to: ${topReceivers}.${failedProjects.length > 0 ? ` ${failedProjects.length} could not be reassigned.` : ''}`,
|
||
|
|
linkUrl: `/admin/rounds/${round.id}`,
|
||
|
|
linkLabel: 'View Round',
|
||
|
|
metadata: { roundId: round.id, sourceJurorId: input.jurorId, movedCount: actualMoves.length, failedCount: failedProjects.length },
|
||
|
|
})
|
||
|
|
|
||
|
|
await logAudit({
|
||
|
|
prisma: ctx.prisma, userId: ctx.user.id, action: 'ASSIGNMENT_REDISTRIBUTE',
|
||
|
|
entityType: 'Round', entityId: round.id,
|
||
|
|
detailsJson: { sourceJurorId: input.jurorId, sourceName, movedCount: actualMoves.length, failedCount: failedProjects.length },
|
||
|
|
ipAddress: ctx.ip, userAgent: ctx.userAgent,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
return { movedCount: actualMoves.length, failedCount: failedProjects.length, failedProjects }
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get transfer candidates: which of the source juror's assignments can be moved,
|
||
|
|
* and which other jurors are eligible to receive them.
|
||
|
|
*/
|
||
|
|
getTransferCandidates: adminProcedure
|
||
|
|
.input(z.object({
|
||
|
|
roundId: z.string(),
|
||
|
|
sourceJurorId: z.string(),
|
||
|
|
assignmentIds: z.array(z.string()),
|
||
|
|
}))
|
||
|
|
.query(async ({ ctx, input }) => {
|
||
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
||
|
|
where: { id: input.roundId },
|
||
|
|
select: { id: true, name: true, configJson: true, juryGroupId: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const config = (round.configJson ?? {}) as Record<string, unknown>
|
||
|
|
const fallbackCap =
|
||
|
|
(config.maxLoadPerJuror as number) ??
|
||
|
|
(config.maxAssignmentsPerJuror as number) ??
|
||
|
|
20
|
||
|
|
|
||
|
|
// Fetch requested assignments — must belong to source juror
|
||
|
|
const requestedAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: {
|
||
|
|
id: { in: input.assignmentIds },
|
||
|
|
roundId: input.roundId,
|
||
|
|
userId: input.sourceJurorId,
|
||
|
|
},
|
||
|
|
select: {
|
||
|
|
id: true,
|
||
|
|
projectId: true,
|
||
|
|
project: { select: { title: true } },
|
||
|
|
evaluation: { select: { status: true } },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Filter to movable only
|
||
|
|
const assignments = requestedAssignments.map((a) => ({
|
||
|
|
id: a.id,
|
||
|
|
projectId: a.projectId,
|
||
|
|
projectTitle: a.project.title,
|
||
|
|
evalStatus: a.evaluation?.status ?? null,
|
||
|
|
movable: !a.evaluation || MOVABLE_EVAL_STATUSES.includes(a.evaluation.status as typeof MOVABLE_EVAL_STATUSES[number]),
|
||
|
|
}))
|
||
|
|
|
||
|
|
const movableProjectIds = assignments
|
||
|
|
.filter((a) => a.movable)
|
||
|
|
.map((a) => a.projectId)
|
||
|
|
|
||
|
|
// Build candidate juror pool — same pattern as reassignDroppedJurorAssignments
|
||
|
|
const candidateJurors = await getCandidateJurors(
|
||
|
|
ctx.prisma,
|
||
|
|
input.roundId,
|
||
|
|
round.juryGroupId,
|
||
|
|
input.sourceJurorId,
|
||
|
|
)
|
||
|
|
|
||
|
|
const candidateIds = candidateJurors.map((j) => j.id)
|
||
|
|
|
||
|
|
// Existing assignments, loads, COI pairs
|
||
|
|
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: { roundId: input.roundId },
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const currentLoads = new Map<string, number>()
|
||
|
|
for (const a of existingAssignments) {
|
||
|
|
currentLoads.set(a.userId, (currentLoads.get(a.userId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
const alreadyAssigned = new Set(existingAssignments.map((a) => `${a.userId}:${a.projectId}`))
|
||
|
|
|
||
|
|
// Completed evaluations count per candidate
|
||
|
|
const completedEvals = await ctx.prisma.evaluation.findMany({
|
||
|
|
where: {
|
||
|
|
assignment: { roundId: input.roundId, userId: { in: candidateIds } },
|
||
|
|
status: 'SUBMITTED',
|
||
|
|
},
|
||
|
|
select: { assignment: { select: { userId: true } } },
|
||
|
|
})
|
||
|
|
const completedCounts = new Map<string, number>()
|
||
|
|
for (const e of completedEvals) {
|
||
|
|
const uid = e.assignment.userId
|
||
|
|
completedCounts.set(uid, (completedCounts.get(uid) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
const coiRecords = await ctx.prisma.conflictOfInterest.findMany({
|
||
|
|
where: {
|
||
|
|
assignment: { roundId: input.roundId },
|
||
|
|
hasConflict: true,
|
||
|
|
userId: { in: candidateIds },
|
||
|
|
},
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const coiPairs = new Set(coiRecords.map((c) => `${c.userId}:${c.projectId}`))
|
||
|
|
|
||
|
|
// Build candidate list with eligibility per project
|
||
|
|
const candidates = candidateJurors.map((j) => {
|
||
|
|
const load = currentLoads.get(j.id) ?? 0
|
||
|
|
const cap = j.maxAssignments ?? fallbackCap
|
||
|
|
const completed = completedCounts.get(j.id) ?? 0
|
||
|
|
const allCompleted = load > 0 && completed === load
|
||
|
|
|
||
|
|
const eligibleProjectIds = movableProjectIds.filter((pid) =>
|
||
|
|
!alreadyAssigned.has(`${j.id}:${pid}`) &&
|
||
|
|
!coiPairs.has(`${j.id}:${pid}`) &&
|
||
|
|
load < cap
|
||
|
|
)
|
||
|
|
|
||
|
|
// Track which movable projects this candidate already has assigned
|
||
|
|
const alreadyAssignedProjectIds = movableProjectIds.filter((pid) =>
|
||
|
|
alreadyAssigned.has(`${j.id}:${pid}`)
|
||
|
|
)
|
||
|
|
|
||
|
|
return {
|
||
|
|
userId: j.id,
|
||
|
|
name: j.name || j.email,
|
||
|
|
email: j.email,
|
||
|
|
currentLoad: load,
|
||
|
|
cap,
|
||
|
|
allCompleted,
|
||
|
|
eligibleProjectIds,
|
||
|
|
alreadyAssignedProjectIds,
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
// Sort: not-all-done first, then by lowest load
|
||
|
|
candidates.sort((a, b) => {
|
||
|
|
if (a.allCompleted !== b.allCompleted) return a.allCompleted ? 1 : -1
|
||
|
|
return a.currentLoad - b.currentLoad
|
||
|
|
})
|
||
|
|
|
||
|
|
return { assignments, candidates }
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Transfer specific assignments from one juror to destination jurors.
|
||
|
|
*/
|
||
|
|
transferAssignments: adminProcedure
|
||
|
|
.input(z.object({
|
||
|
|
roundId: z.string(),
|
||
|
|
sourceJurorId: z.string(),
|
||
|
|
transfers: z.array(z.object({
|
||
|
|
assignmentId: z.string(),
|
||
|
|
destinationJurorId: z.string(),
|
||
|
|
})),
|
||
|
|
forceOverCap: z.boolean().default(false),
|
||
|
|
}))
|
||
|
|
.mutation(async ({ ctx, input }) => {
|
||
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
||
|
|
where: { id: input.roundId },
|
||
|
|
select: { id: true, name: true, configJson: true, juryGroupId: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const config = (round.configJson ?? {}) as Record<string, unknown>
|
||
|
|
const fallbackCap =
|
||
|
|
(config.maxLoadPerJuror as number) ??
|
||
|
|
(config.maxAssignmentsPerJuror as number) ??
|
||
|
|
20
|
||
|
|
|
||
|
|
// Verify all assignments belong to source juror and are movable
|
||
|
|
const assignmentIds = input.transfers.map((t) => t.assignmentId)
|
||
|
|
const sourceAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: {
|
||
|
|
id: { in: assignmentIds },
|
||
|
|
roundId: input.roundId,
|
||
|
|
userId: input.sourceJurorId,
|
||
|
|
OR: [
|
||
|
|
{ evaluation: null },
|
||
|
|
{ evaluation: { status: { in: [...MOVABLE_EVAL_STATUSES] } } },
|
||
|
|
],
|
||
|
|
},
|
||
|
|
select: {
|
||
|
|
id: true,
|
||
|
|
projectId: true,
|
||
|
|
juryGroupId: true,
|
||
|
|
isRequired: true,
|
||
|
|
project: { select: { title: true } },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
const sourceMap = new Map(sourceAssignments.map((a) => [a.id, a]))
|
||
|
|
|
||
|
|
// Build candidate pool data
|
||
|
|
const destinationIds = [...new Set(input.transfers.map((t) => t.destinationJurorId))]
|
||
|
|
const destinationUsers = await ctx.prisma.user.findMany({
|
||
|
|
where: { id: { in: destinationIds } },
|
||
|
|
select: { id: true, name: true, email: true, maxAssignments: true },
|
||
|
|
})
|
||
|
|
const destUserMap = new Map(destinationUsers.map((u) => [u.id, u]))
|
||
|
|
|
||
|
|
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: { roundId: input.roundId },
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const alreadyAssigned = new Set(existingAssignments.map((a) => `${a.userId}:${a.projectId}`))
|
||
|
|
const currentLoads = new Map<string, number>()
|
||
|
|
for (const a of existingAssignments) {
|
||
|
|
currentLoads.set(a.userId, (currentLoads.get(a.userId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
const coiRecords = await ctx.prisma.conflictOfInterest.findMany({
|
||
|
|
where: {
|
||
|
|
assignment: { roundId: input.roundId },
|
||
|
|
hasConflict: true,
|
||
|
|
userId: { in: destinationIds },
|
||
|
|
},
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const coiPairs = new Set(coiRecords.map((c) => `${c.userId}:${c.projectId}`))
|
||
|
|
|
||
|
|
// Validate each transfer
|
||
|
|
type PlannedMove = {
|
||
|
|
assignmentId: string
|
||
|
|
projectId: string
|
||
|
|
projectTitle: string
|
||
|
|
destinationJurorId: string
|
||
|
|
juryGroupId: string | null
|
||
|
|
isRequired: boolean
|
||
|
|
}
|
||
|
|
const plannedMoves: PlannedMove[] = []
|
||
|
|
const failed: { assignmentId: string; reason: string }[] = []
|
||
|
|
|
||
|
|
for (const transfer of input.transfers) {
|
||
|
|
const assignment = sourceMap.get(transfer.assignmentId)
|
||
|
|
if (!assignment) {
|
||
|
|
failed.push({ assignmentId: transfer.assignmentId, reason: 'Assignment not found or not movable' })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
const destUser = destUserMap.get(transfer.destinationJurorId)
|
||
|
|
if (!destUser) {
|
||
|
|
failed.push({ assignmentId: transfer.assignmentId, reason: 'Destination juror not found' })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
if (alreadyAssigned.has(`${transfer.destinationJurorId}:${assignment.projectId}`)) {
|
||
|
|
failed.push({ assignmentId: transfer.assignmentId, reason: `${destUser.name || destUser.email} is already assigned to this project` })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
if (coiPairs.has(`${transfer.destinationJurorId}:${assignment.projectId}`)) {
|
||
|
|
failed.push({ assignmentId: transfer.assignmentId, reason: `${destUser.name || destUser.email} has a COI with this project` })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
const destCap = destUser.maxAssignments ?? fallbackCap
|
||
|
|
const destLoad = currentLoads.get(transfer.destinationJurorId) ?? 0
|
||
|
|
if (destLoad >= destCap && !input.forceOverCap) {
|
||
|
|
failed.push({ assignmentId: transfer.assignmentId, reason: `${destUser.name || destUser.email} is at cap (${destLoad}/${destCap})` })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
plannedMoves.push({
|
||
|
|
assignmentId: assignment.id,
|
||
|
|
projectId: assignment.projectId,
|
||
|
|
projectTitle: assignment.project.title,
|
||
|
|
destinationJurorId: transfer.destinationJurorId,
|
||
|
|
juryGroupId: assignment.juryGroupId ?? round.juryGroupId,
|
||
|
|
isRequired: assignment.isRequired,
|
||
|
|
})
|
||
|
|
|
||
|
|
// Track updated load for subsequent transfers to same destination
|
||
|
|
alreadyAssigned.add(`${transfer.destinationJurorId}:${assignment.projectId}`)
|
||
|
|
currentLoads.set(transfer.destinationJurorId, destLoad + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Execute in transaction with TOCTOU guard
|
||
|
|
const actualMoves: (PlannedMove & { newAssignmentId: string })[] = []
|
||
|
|
|
||
|
|
if (plannedMoves.length > 0) {
|
||
|
|
await ctx.prisma.$transaction(async (tx) => {
|
||
|
|
for (const move of plannedMoves) {
|
||
|
|
const deleted = await tx.assignment.deleteMany({
|
||
|
|
where: {
|
||
|
|
id: move.assignmentId,
|
||
|
|
userId: input.sourceJurorId,
|
||
|
|
OR: [
|
||
|
|
{ evaluation: null },
|
||
|
|
{ evaluation: { status: { in: [...MOVABLE_EVAL_STATUSES] } } },
|
||
|
|
],
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
if (deleted.count === 0) {
|
||
|
|
failed.push({ assignmentId: move.assignmentId, reason: 'Assignment was modified concurrently' })
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
const created = await tx.assignment.create({
|
||
|
|
data: {
|
||
|
|
roundId: input.roundId,
|
||
|
|
projectId: move.projectId,
|
||
|
|
userId: move.destinationJurorId,
|
||
|
|
juryGroupId: move.juryGroupId ?? undefined,
|
||
|
|
isRequired: move.isRequired,
|
||
|
|
method: 'MANUAL',
|
||
|
|
createdBy: ctx.user.id,
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
actualMoves.push({ ...move, newAssignmentId: created.id })
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify destination jurors with per-juror project names
|
||
|
|
if (actualMoves.length > 0) {
|
||
|
|
const destMoves: Record<string, string[]> = {}
|
||
|
|
for (const move of actualMoves) {
|
||
|
|
if (!destMoves[move.destinationJurorId]) destMoves[move.destinationJurorId] = []
|
||
|
|
destMoves[move.destinationJurorId].push(move.projectTitle)
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const [jurorId, projectNames] of Object.entries(destMoves)) {
|
||
|
|
const count = projectNames.length
|
||
|
|
await createNotification({
|
||
|
|
userId: jurorId,
|
||
|
|
type: NotificationTypes.MANUAL_REASSIGNED,
|
||
|
|
title: count === 1 ? 'Project Reassigned to You' : `${count} Projects Reassigned to You`,
|
||
|
|
message: count === 1
|
||
|
|
? `The project "${projectNames[0]}" has been reassigned to you for evaluation in ${round.name}.`
|
||
|
|
: `${count} projects have been reassigned to you for evaluation in ${round.name}: ${projectNames.join(', ')}.`,
|
||
|
|
linkUrl: `/jury/competitions`,
|
||
|
|
linkLabel: 'View Assignments',
|
||
|
|
metadata: { roundId: round.id, roundName: round.name, projectNames, reason: 'admin_transfer' },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify admins
|
||
|
|
const sourceJuror = await ctx.prisma.user.findUnique({
|
||
|
|
where: { id: input.sourceJurorId },
|
||
|
|
select: { name: true, email: true },
|
||
|
|
})
|
||
|
|
const sourceName = sourceJuror?.name || sourceJuror?.email || 'Unknown'
|
||
|
|
|
||
|
|
const topReceivers = Object.entries(destMoves)
|
||
|
|
.map(([jurorId, projects]) => {
|
||
|
|
const u = destUserMap.get(jurorId)
|
||
|
|
return `${u?.name || u?.email || jurorId} (${projects.length})`
|
||
|
|
})
|
||
|
|
.join(', ')
|
||
|
|
|
||
|
|
await notifyAdmins({
|
||
|
|
type: NotificationTypes.EVALUATION_MILESTONE,
|
||
|
|
title: 'Assignment Transfer',
|
||
|
|
message: `Transferred ${actualMoves.length} project(s) from ${sourceName} to: ${topReceivers}.${failed.length > 0 ? ` ${failed.length} transfer(s) failed.` : ''}`,
|
||
|
|
linkUrl: `/admin/rounds/${round.id}`,
|
||
|
|
linkLabel: 'View Round',
|
||
|
|
metadata: {
|
||
|
|
roundId: round.id,
|
||
|
|
sourceJurorId: input.sourceJurorId,
|
||
|
|
movedCount: actualMoves.length,
|
||
|
|
failedCount: failed.length,
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Audit
|
||
|
|
await logAudit({
|
||
|
|
prisma: ctx.prisma,
|
||
|
|
userId: ctx.user.id,
|
||
|
|
action: 'ASSIGNMENT_TRANSFER',
|
||
|
|
entityType: 'Round',
|
||
|
|
entityId: round.id,
|
||
|
|
detailsJson: {
|
||
|
|
sourceJurorId: input.sourceJurorId,
|
||
|
|
sourceJurorName: sourceName,
|
||
|
|
movedCount: actualMoves.length,
|
||
|
|
failedCount: failed.length,
|
||
|
|
moves: actualMoves.map((m) => ({
|
||
|
|
projectId: m.projectId,
|
||
|
|
projectTitle: m.projectTitle,
|
||
|
|
newJurorId: m.destinationJurorId,
|
||
|
|
newJurorName: destUserMap.get(m.destinationJurorId)?.name || destUserMap.get(m.destinationJurorId)?.email || m.destinationJurorId,
|
||
|
|
})),
|
||
|
|
},
|
||
|
|
ipAddress: ctx.ip,
|
||
|
|
userAgent: ctx.userAgent,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
succeeded: actualMoves.map((m) => ({
|
||
|
|
assignmentId: m.assignmentId,
|
||
|
|
projectId: m.projectId,
|
||
|
|
destinationJurorId: m.destinationJurorId,
|
||
|
|
})),
|
||
|
|
failed,
|
||
|
|
}
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Preview the impact of lowering a juror's cap below their current load.
|
||
|
|
*/
|
||
|
|
getOverCapPreview: adminProcedure
|
||
|
|
.input(z.object({
|
||
|
|
roundId: z.string(),
|
||
|
|
jurorId: z.string(),
|
||
|
|
newCap: z.number().int().min(1),
|
||
|
|
}))
|
||
|
|
.query(async ({ ctx, input }) => {
|
||
|
|
const total = await ctx.prisma.assignment.count({
|
||
|
|
where: { roundId: input.roundId, userId: input.jurorId },
|
||
|
|
})
|
||
|
|
|
||
|
|
const immovableCount = await ctx.prisma.assignment.count({
|
||
|
|
where: {
|
||
|
|
roundId: input.roundId,
|
||
|
|
userId: input.jurorId,
|
||
|
|
evaluation: { status: { notIn: [...MOVABLE_EVAL_STATUSES] } },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
const movableCount = total - immovableCount
|
||
|
|
const overCapCount = Math.max(0, total - input.newCap)
|
||
|
|
|
||
|
|
return {
|
||
|
|
total,
|
||
|
|
overCapCount,
|
||
|
|
movableOverCap: Math.min(overCapCount, movableCount),
|
||
|
|
immovableOverCap: Math.max(0, overCapCount - movableCount),
|
||
|
|
}
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Redistribute over-cap assignments after lowering a juror's cap.
|
||
|
|
* Moves the newest/least-progressed movable assignments to other eligible jurors.
|
||
|
|
*/
|
||
|
|
redistributeOverCap: adminProcedure
|
||
|
|
.input(z.object({
|
||
|
|
roundId: z.string(),
|
||
|
|
jurorId: z.string(),
|
||
|
|
newCap: z.number().int().min(1),
|
||
|
|
}))
|
||
|
|
.mutation(async ({ ctx, input }) => {
|
||
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
||
|
|
where: { id: input.roundId },
|
||
|
|
select: { id: true, name: true, configJson: true, juryGroupId: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const config = (round.configJson ?? {}) as Record<string, unknown>
|
||
|
|
const fallbackCap =
|
||
|
|
(config.maxLoadPerJuror as number) ??
|
||
|
|
(config.maxAssignmentsPerJuror as number) ??
|
||
|
|
20
|
||
|
|
|
||
|
|
// Get juror's assignments sorted: null eval first, then DRAFT, newest first
|
||
|
|
const jurorAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: { roundId: input.roundId, userId: input.jurorId },
|
||
|
|
select: {
|
||
|
|
id: true,
|
||
|
|
projectId: true,
|
||
|
|
juryGroupId: true,
|
||
|
|
isRequired: true,
|
||
|
|
createdAt: true,
|
||
|
|
project: { select: { title: true } },
|
||
|
|
evaluation: { select: { status: true } },
|
||
|
|
},
|
||
|
|
orderBy: { createdAt: 'desc' },
|
||
|
|
})
|
||
|
|
|
||
|
|
const overCapCount = Math.max(0, jurorAssignments.length - input.newCap)
|
||
|
|
if (overCapCount === 0) {
|
||
|
|
return { redistributed: 0, failed: 0, failedProjects: [] as string[], moves: [] as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[] }
|
||
|
|
}
|
||
|
|
|
||
|
|
// Separate movable and immovable, pick the newest movable ones for redistribution
|
||
|
|
const movable = jurorAssignments.filter(
|
||
|
|
(a) => !a.evaluation || MOVABLE_EVAL_STATUSES.includes(a.evaluation.status as typeof MOVABLE_EVAL_STATUSES[number])
|
||
|
|
)
|
||
|
|
|
||
|
|
// Sort movable: null eval first, then DRAFT, then by createdAt descending (newest first to remove)
|
||
|
|
movable.sort((a, b) => {
|
||
|
|
const statusOrder = (s: string | null) => s === null ? 0 : s === 'NOT_STARTED' ? 1 : s === 'DRAFT' ? 2 : 3
|
||
|
|
const diff = statusOrder(a.evaluation?.status ?? null) - statusOrder(b.evaluation?.status ?? null)
|
||
|
|
if (diff !== 0) return diff
|
||
|
|
return b.createdAt.getTime() - a.createdAt.getTime()
|
||
|
|
})
|
||
|
|
|
||
|
|
const assignmentsToMove = movable.slice(0, overCapCount)
|
||
|
|
|
||
|
|
if (assignmentsToMove.length === 0) {
|
||
|
|
return { redistributed: 0, failed: 0, failedProjects: [] as string[], moves: [] as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[] }
|
||
|
|
}
|
||
|
|
|
||
|
|
// Build candidate pool — same pattern as reassignDroppedJurorAssignments
|
||
|
|
const candidateJurors = await getCandidateJurors(
|
||
|
|
ctx.prisma,
|
||
|
|
input.roundId,
|
||
|
|
round.juryGroupId,
|
||
|
|
input.jurorId,
|
||
|
|
)
|
||
|
|
|
||
|
|
if (candidateJurors.length === 0) {
|
||
|
|
return {
|
||
|
|
redistributed: 0,
|
||
|
|
failed: assignmentsToMove.length,
|
||
|
|
failedProjects: assignmentsToMove.map((a) => a.project.title),
|
||
|
|
moves: [] as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[],
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const candidateIds = candidateJurors.map((j) => j.id)
|
||
|
|
|
||
|
|
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: { roundId: input.roundId },
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
|
||
|
|
const alreadyAssigned = new Set(existingAssignments.map((a) => `${a.userId}:${a.projectId}`))
|
||
|
|
const currentLoads = new Map<string, number>()
|
||
|
|
for (const a of existingAssignments) {
|
||
|
|
currentLoads.set(a.userId, (currentLoads.get(a.userId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
const coiRecords = await ctx.prisma.conflictOfInterest.findMany({
|
||
|
|
where: {
|
||
|
|
assignment: { roundId: input.roundId },
|
||
|
|
hasConflict: true,
|
||
|
|
userId: { in: candidateIds },
|
||
|
|
},
|
||
|
|
select: { userId: true, projectId: true },
|
||
|
|
})
|
||
|
|
const coiPairs = new Set(coiRecords.map((c) => `${c.userId}:${c.projectId}`))
|
||
|
|
|
||
|
|
const caps = new Map<string, number>()
|
||
|
|
for (const juror of candidateJurors) {
|
||
|
|
caps.set(juror.id, juror.maxAssignments ?? fallbackCap)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check which candidates have completed all their evaluations
|
||
|
|
const completedEvals = await ctx.prisma.evaluation.findMany({
|
||
|
|
where: {
|
||
|
|
assignment: { roundId: input.roundId, userId: { in: candidateIds } },
|
||
|
|
status: 'SUBMITTED',
|
||
|
|
},
|
||
|
|
select: { assignment: { select: { userId: true } } },
|
||
|
|
})
|
||
|
|
const completedCounts = new Map<string, number>()
|
||
|
|
for (const e of completedEvals) {
|
||
|
|
completedCounts.set(e.assignment.userId, (completedCounts.get(e.assignment.userId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
const candidateMeta = new Map(candidateJurors.map((j) => [j.id, j]))
|
||
|
|
|
||
|
|
type PlannedMove = {
|
||
|
|
assignmentId: string
|
||
|
|
projectId: string
|
||
|
|
projectTitle: string
|
||
|
|
newJurorId: string
|
||
|
|
juryGroupId: string | null
|
||
|
|
isRequired: boolean
|
||
|
|
}
|
||
|
|
const plannedMoves: PlannedMove[] = []
|
||
|
|
const failedProjects: string[] = []
|
||
|
|
|
||
|
|
for (const assignment of assignmentsToMove) {
|
||
|
|
const eligible = candidateIds
|
||
|
|
.filter((jurorId) => !alreadyAssigned.has(`${jurorId}:${assignment.projectId}`))
|
||
|
|
.filter((jurorId) => !coiPairs.has(`${jurorId}:${assignment.projectId}`))
|
||
|
|
.filter((jurorId) => (currentLoads.get(jurorId) ?? 0) < (caps.get(jurorId) ?? fallbackCap))
|
||
|
|
.sort((a, b) => {
|
||
|
|
// Prefer jurors who haven't completed all their work
|
||
|
|
const aLoad = currentLoads.get(a) ?? 0
|
||
|
|
const bLoad = currentLoads.get(b) ?? 0
|
||
|
|
const aComplete = aLoad > 0 && (completedCounts.get(a) ?? 0) === aLoad
|
||
|
|
const bComplete = bLoad > 0 && (completedCounts.get(b) ?? 0) === bLoad
|
||
|
|
if (aComplete !== bComplete) return aComplete ? 1 : -1
|
||
|
|
const loadDiff = aLoad - bLoad
|
||
|
|
if (loadDiff !== 0) return loadDiff
|
||
|
|
return a.localeCompare(b)
|
||
|
|
})
|
||
|
|
|
||
|
|
if (eligible.length === 0) {
|
||
|
|
failedProjects.push(assignment.project.title)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
const selectedJurorId = eligible[0]
|
||
|
|
plannedMoves.push({
|
||
|
|
assignmentId: assignment.id,
|
||
|
|
projectId: assignment.projectId,
|
||
|
|
projectTitle: assignment.project.title,
|
||
|
|
newJurorId: selectedJurorId,
|
||
|
|
juryGroupId: assignment.juryGroupId ?? round.juryGroupId,
|
||
|
|
isRequired: assignment.isRequired,
|
||
|
|
})
|
||
|
|
|
||
|
|
alreadyAssigned.add(`${selectedJurorId}:${assignment.projectId}`)
|
||
|
|
currentLoads.set(selectedJurorId, (currentLoads.get(selectedJurorId) ?? 0) + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Execute in transaction with TOCTOU guard
|
||
|
|
const actualMoves: PlannedMove[] = []
|
||
|
|
|
||
|
|
if (plannedMoves.length > 0) {
|
||
|
|
await ctx.prisma.$transaction(async (tx) => {
|
||
|
|
for (const move of plannedMoves) {
|
||
|
|
const deleted = await tx.assignment.deleteMany({
|
||
|
|
where: {
|
||
|
|
id: move.assignmentId,
|
||
|
|
userId: input.jurorId,
|
||
|
|
OR: [
|
||
|
|
{ evaluation: null },
|
||
|
|
{ evaluation: { status: { in: [...MOVABLE_EVAL_STATUSES] } } },
|
||
|
|
],
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
if (deleted.count === 0) {
|
||
|
|
failedProjects.push(move.projectTitle)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
await tx.assignment.create({
|
||
|
|
data: {
|
||
|
|
roundId: input.roundId,
|
||
|
|
projectId: move.projectId,
|
||
|
|
userId: move.newJurorId,
|
||
|
|
juryGroupId: move.juryGroupId ?? undefined,
|
||
|
|
isRequired: move.isRequired,
|
||
|
|
method: 'MANUAL',
|
||
|
|
createdBy: ctx.user.id,
|
||
|
|
},
|
||
|
|
})
|
||
|
|
actualMoves.push(move)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify destination jurors
|
||
|
|
if (actualMoves.length > 0) {
|
||
|
|
const destCounts: Record<string, number> = {}
|
||
|
|
for (const move of actualMoves) {
|
||
|
|
destCounts[move.newJurorId] = (destCounts[move.newJurorId] ?? 0) + 1
|
||
|
|
}
|
||
|
|
|
||
|
|
await createBulkNotifications({
|
||
|
|
userIds: Object.keys(destCounts),
|
||
|
|
type: NotificationTypes.BATCH_ASSIGNED,
|
||
|
|
title: 'Additional Projects Assigned',
|
||
|
|
message: `You have received additional project assignments due to a cap adjustment in ${round.name}.`,
|
||
|
|
linkUrl: `/jury/competitions`,
|
||
|
|
linkLabel: 'View Assignments',
|
||
|
|
metadata: { roundId: round.id, reason: 'cap_redistribute' },
|
||
|
|
})
|
||
|
|
|
||
|
|
const juror = await ctx.prisma.user.findUnique({
|
||
|
|
where: { id: input.jurorId },
|
||
|
|
select: { name: true, email: true },
|
||
|
|
})
|
||
|
|
const jurorName = juror?.name || juror?.email || 'Unknown'
|
||
|
|
|
||
|
|
const topReceivers = Object.entries(destCounts)
|
||
|
|
.map(([jurorId, count]) => {
|
||
|
|
const u = candidateMeta.get(jurorId)
|
||
|
|
return `${u?.name || u?.email || jurorId} (${count})`
|
||
|
|
})
|
||
|
|
.join(', ')
|
||
|
|
|
||
|
|
await notifyAdmins({
|
||
|
|
type: NotificationTypes.EVALUATION_MILESTONE,
|
||
|
|
title: 'Cap Redistribution',
|
||
|
|
message: `Redistributed ${actualMoves.length} project(s) from ${jurorName} (cap lowered to ${input.newCap}) to: ${topReceivers}.${failedProjects.length > 0 ? ` ${failedProjects.length} project(s) could not be reassigned.` : ''}`,
|
||
|
|
linkUrl: `/admin/rounds/${round.id}`,
|
||
|
|
linkLabel: 'View Round',
|
||
|
|
metadata: {
|
||
|
|
roundId: round.id,
|
||
|
|
jurorId: input.jurorId,
|
||
|
|
newCap: input.newCap,
|
||
|
|
movedCount: actualMoves.length,
|
||
|
|
failedCount: failedProjects.length,
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
await logAudit({
|
||
|
|
prisma: ctx.prisma,
|
||
|
|
userId: ctx.user.id,
|
||
|
|
action: 'CAP_REDISTRIBUTE',
|
||
|
|
entityType: 'Round',
|
||
|
|
entityId: round.id,
|
||
|
|
detailsJson: {
|
||
|
|
jurorId: input.jurorId,
|
||
|
|
jurorName,
|
||
|
|
newCap: input.newCap,
|
||
|
|
movedCount: actualMoves.length,
|
||
|
|
failedCount: failedProjects.length,
|
||
|
|
failedProjects,
|
||
|
|
moves: actualMoves.map((m) => ({
|
||
|
|
projectId: m.projectId,
|
||
|
|
projectTitle: m.projectTitle,
|
||
|
|
newJurorId: m.newJurorId,
|
||
|
|
newJurorName: candidateMeta.get(m.newJurorId)?.name || candidateMeta.get(m.newJurorId)?.email || m.newJurorId,
|
||
|
|
})),
|
||
|
|
},
|
||
|
|
ipAddress: ctx.ip,
|
||
|
|
userAgent: ctx.userAgent,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
redistributed: actualMoves.length,
|
||
|
|
failed: failedProjects.length,
|
||
|
|
failedProjects,
|
||
|
|
moves: actualMoves.map((m) => ({
|
||
|
|
projectId: m.projectId,
|
||
|
|
projectTitle: m.projectTitle,
|
||
|
|
newJurorId: m.newJurorId,
|
||
|
|
newJurorName: candidateMeta.get(m.newJurorId)?.name || candidateMeta.get(m.newJurorId)?.email || m.newJurorId,
|
||
|
|
})),
|
||
|
|
}
|
||
|
|
}),
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get reshuffle history for a round — shows all dropout/COI reassignment events
|
||
|
|
* with per-project detail of where each project was moved to.
|
||
|
|
*/
|
||
|
|
getReassignmentHistory: adminProcedure
|
||
|
|
.input(z.object({ roundId: z.string() }))
|
||
|
|
.query(async ({ ctx, input }) => {
|
||
|
|
// Get all reshuffle + COI audit entries for this round
|
||
|
|
const auditEntries = await ctx.prisma.auditLog.findMany({
|
||
|
|
where: {
|
||
|
|
entityType: { in: ['Round', 'Assignment'] },
|
||
|
|
action: { in: ['JUROR_DROPOUT_RESHUFFLE', 'COI_REASSIGNMENT', 'ASSIGNMENT_TRANSFER', 'CAP_REDISTRIBUTE'] },
|
||
|
|
entityId: input.roundId,
|
||
|
|
},
|
||
|
|
orderBy: { timestamp: 'desc' },
|
||
|
|
include: {
|
||
|
|
user: { select: { id: true, name: true, email: true } },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Also get COI reassignment entries that reference this round in detailsJson
|
||
|
|
const coiEntries = await ctx.prisma.auditLog.findMany({
|
||
|
|
where: {
|
||
|
|
action: 'COI_REASSIGNMENT',
|
||
|
|
entityType: 'Assignment',
|
||
|
|
},
|
||
|
|
orderBy: { timestamp: 'desc' },
|
||
|
|
include: {
|
||
|
|
user: { select: { id: true, name: true, email: true } },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Filter COI entries to this round
|
||
|
|
const coiForRound = coiEntries.filter((e) => {
|
||
|
|
const details = e.detailsJson as Record<string, unknown> | null
|
||
|
|
return details?.roundId === input.roundId
|
||
|
|
})
|
||
|
|
|
||
|
|
// For retroactive data: find all MANUAL assignments created in this round
|
||
|
|
// that were created by an admin (not the juror themselves)
|
||
|
|
const manualAssignments = await ctx.prisma.assignment.findMany({
|
||
|
|
where: {
|
||
|
|
roundId: input.roundId,
|
||
|
|
method: 'MANUAL',
|
||
|
|
createdBy: { not: null },
|
||
|
|
},
|
||
|
|
include: {
|
||
|
|
user: { select: { id: true, name: true, email: true } },
|
||
|
|
project: { select: { id: true, title: true } },
|
||
|
|
},
|
||
|
|
orderBy: { createdAt: 'desc' },
|
||
|
|
})
|
||
|
|
|
||
|
|
type ReshuffleEvent = {
|
||
|
|
id: string
|
||
|
|
type: 'DROPOUT' | 'COI' | 'TRANSFER' | 'CAP_REDISTRIBUTE'
|
||
|
|
timestamp: Date
|
||
|
|
performedBy: { name: string | null; email: string }
|
||
|
|
droppedJuror: { id: string; name: string }
|
||
|
|
movedCount: number
|
||
|
|
failedCount: number
|
||
|
|
failedProjects: string[]
|
||
|
|
moves: { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[]
|
||
|
|
}
|
||
|
|
|
||
|
|
const events: ReshuffleEvent[] = []
|
||
|
|
|
||
|
|
for (const entry of auditEntries) {
|
||
|
|
const details = entry.detailsJson as Record<string, unknown> | null
|
||
|
|
if (!details) continue
|
||
|
|
|
||
|
|
if (entry.action === 'JUROR_DROPOUT_RESHUFFLE') {
|
||
|
|
// Check if this entry already has per-move detail (new format)
|
||
|
|
const moves = (details.moves as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[]) || []
|
||
|
|
|
||
|
|
// If no moves in audit (old format), reconstruct from assignments
|
||
|
|
let reconstructedMoves = moves
|
||
|
|
if (moves.length === 0 && (details.movedCount as number) > 0) {
|
||
|
|
// Find MANUAL assignments created around the same time (within 5 seconds)
|
||
|
|
const eventTime = entry.timestamp.getTime()
|
||
|
|
reconstructedMoves = manualAssignments
|
||
|
|
.filter((a) => {
|
||
|
|
const diff = Math.abs(a.createdAt.getTime() - eventTime)
|
||
|
|
return diff < 5000 && a.createdBy === entry.userId
|
||
|
|
})
|
||
|
|
.map((a) => ({
|
||
|
|
projectId: a.project.id,
|
||
|
|
projectTitle: a.project.title,
|
||
|
|
newJurorId: a.user.id,
|
||
|
|
newJurorName: a.user.name || a.user.email,
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
events.push({
|
||
|
|
id: entry.id,
|
||
|
|
type: 'DROPOUT',
|
||
|
|
timestamp: entry.timestamp,
|
||
|
|
performedBy: {
|
||
|
|
name: entry.user?.name ?? null,
|
||
|
|
email: entry.user?.email ?? '',
|
||
|
|
},
|
||
|
|
droppedJuror: {
|
||
|
|
id: details.droppedJurorId as string,
|
||
|
|
name: (details.droppedJurorName as string) || 'Unknown',
|
||
|
|
},
|
||
|
|
movedCount: (details.movedCount as number) || 0,
|
||
|
|
failedCount: (details.failedCount as number) || 0,
|
||
|
|
failedProjects: (details.failedProjects as string[]) || [],
|
||
|
|
moves: reconstructedMoves,
|
||
|
|
})
|
||
|
|
} else if (entry.action === 'ASSIGNMENT_TRANSFER') {
|
||
|
|
const moves = (details.moves as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[]) || []
|
||
|
|
events.push({
|
||
|
|
id: entry.id,
|
||
|
|
type: 'TRANSFER',
|
||
|
|
timestamp: entry.timestamp,
|
||
|
|
performedBy: {
|
||
|
|
name: entry.user?.name ?? null,
|
||
|
|
email: entry.user?.email ?? '',
|
||
|
|
},
|
||
|
|
droppedJuror: {
|
||
|
|
id: (details.sourceJurorId as string) || '',
|
||
|
|
name: (details.sourceJurorName as string) || 'Unknown',
|
||
|
|
},
|
||
|
|
movedCount: (details.movedCount as number) || 0,
|
||
|
|
failedCount: (details.failedCount as number) || 0,
|
||
|
|
failedProjects: (details.failedProjects as string[]) || [],
|
||
|
|
moves,
|
||
|
|
})
|
||
|
|
} else if (entry.action === 'CAP_REDISTRIBUTE') {
|
||
|
|
const moves = (details.moves as { projectId: string; projectTitle: string; newJurorId: string; newJurorName: string }[]) || []
|
||
|
|
events.push({
|
||
|
|
id: entry.id,
|
||
|
|
type: 'CAP_REDISTRIBUTE',
|
||
|
|
timestamp: entry.timestamp,
|
||
|
|
performedBy: {
|
||
|
|
name: entry.user?.name ?? null,
|
||
|
|
email: entry.user?.email ?? '',
|
||
|
|
},
|
||
|
|
droppedJuror: {
|
||
|
|
id: (details.jurorId as string) || '',
|
||
|
|
name: (details.jurorName as string) || 'Unknown',
|
||
|
|
},
|
||
|
|
movedCount: (details.movedCount as number) || 0,
|
||
|
|
failedCount: (details.failedCount as number) || 0,
|
||
|
|
failedProjects: (details.failedProjects as string[]) || [],
|
||
|
|
moves,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Process COI entries
|
||
|
|
for (const entry of coiForRound) {
|
||
|
|
const details = entry.detailsJson as Record<string, unknown> | null
|
||
|
|
if (!details) continue
|
||
|
|
|
||
|
|
// Look up project title
|
||
|
|
const project = details.projectId
|
||
|
|
? await ctx.prisma.project.findUnique({
|
||
|
|
where: { id: details.projectId as string },
|
||
|
|
select: { title: true },
|
||
|
|
})
|
||
|
|
: null
|
||
|
|
|
||
|
|
// Look up new juror name
|
||
|
|
const newJuror = details.newJurorId
|
||
|
|
? await ctx.prisma.user.findUnique({
|
||
|
|
where: { id: details.newJurorId as string },
|
||
|
|
select: { name: true, email: true },
|
||
|
|
})
|
||
|
|
: null
|
||
|
|
|
||
|
|
// Look up old juror name
|
||
|
|
const oldJuror = details.oldJurorId
|
||
|
|
? await ctx.prisma.user.findUnique({
|
||
|
|
where: { id: details.oldJurorId as string },
|
||
|
|
select: { name: true, email: true },
|
||
|
|
})
|
||
|
|
: null
|
||
|
|
|
||
|
|
events.push({
|
||
|
|
id: entry.id,
|
||
|
|
type: 'COI',
|
||
|
|
timestamp: entry.timestamp,
|
||
|
|
performedBy: {
|
||
|
|
name: entry.user?.name ?? null,
|
||
|
|
email: entry.user?.email ?? '',
|
||
|
|
},
|
||
|
|
droppedJuror: {
|
||
|
|
id: (details.oldJurorId as string) || '',
|
||
|
|
name: oldJuror?.name || oldJuror?.email || 'Unknown',
|
||
|
|
},
|
||
|
|
movedCount: 1,
|
||
|
|
failedCount: 0,
|
||
|
|
failedProjects: [],
|
||
|
|
moves: [{
|
||
|
|
projectId: (details.projectId as string) || '',
|
||
|
|
projectTitle: project?.title || 'Unknown',
|
||
|
|
newJurorId: (details.newJurorId as string) || '',
|
||
|
|
newJurorName: newJuror?.name || newJuror?.email || 'Unknown',
|
||
|
|
}],
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sort all events by timestamp descending
|
||
|
|
events.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
|
||
|
|
|
||
|
|
return events
|
||
|
|
}),
|
||
|
|
})
|