refactor: tech debt batch 3 — type safety + assignment router split
All checks were successful
Build and Push Docker Image / build (push) Successful in 13m4s
All checks were successful
Build and Push Docker Image / build (push) Successful in 13m4s
#5 — Replaced 55x PrismaClient | any with proper Prisma types across 8 files - Service files: PrismaClient | any → PrismaClient, tx: any → Prisma.TransactionClient - Fixed 4 real bugs uncovered by typing: - mentor-workspace.ts: wrong FK fields (mentorAssignmentId → workspaceId, role → senderRole) - ai-shortlist.ts: untyped string passed to CompetitionCategory enum filter - result-lock.ts: unknown passed where Prisma.InputJsonValue required #9 — Split assignment.ts (2,775 lines) into 6 focused files: - shared.ts (93 lines) — MOVABLE_EVAL_STATUSES, buildBatchNotifications, getCandidateJurors - assignment-crud.ts (473 lines) — 8 core CRUD procedures - assignment-suggestions.ts (880 lines) — AI suggestions + job runner - assignment-notifications.ts (138 lines) — 2 notification procedures - assignment-redistribution.ts (1,162 lines) — 8 reassign/transfer procedures - index.ts (15 lines) — barrel export with router merge, zero frontend changes Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
880
src/server/routers/assignment/assignment-suggestions.ts
Normal file
880
src/server/routers/assignment/assignment-suggestions.ts
Normal file
@@ -0,0 +1,880 @@
|
||||
import { z } from 'zod'
|
||||
import { TRPCError } from '@trpc/server'
|
||||
import { router, adminProcedure, withAIRateLimit } from '../../trpc'
|
||||
import {
|
||||
generateAIAssignments,
|
||||
type AssignmentProgressCallback,
|
||||
} from '../../services/ai-assignment'
|
||||
import { isOpenAIConfigured } from '@/lib/openai'
|
||||
import { prisma } from '@/lib/prisma'
|
||||
import { notifyAdmins, NotificationTypes } from '../../services/in-app-notification'
|
||||
import { logAudit } from '@/server/utils/audit'
|
||||
import { buildBatchNotifications } from './shared'
|
||||
|
||||
async function runAIAssignmentJob(jobId: string, roundId: string, userId: string) {
|
||||
try {
|
||||
await prisma.assignmentJob.update({
|
||||
where: { id: jobId },
|
||||
data: { status: 'RUNNING', startedAt: new Date() },
|
||||
})
|
||||
|
||||
const round = await prisma.round.findUniqueOrThrow({
|
||||
where: { id: roundId },
|
||||
select: {
|
||||
name: true,
|
||||
configJson: true,
|
||||
competitionId: true,
|
||||
juryGroupId: true,
|
||||
},
|
||||
})
|
||||
|
||||
const config = (round.configJson ?? {}) as Record<string, unknown>
|
||||
const requiredReviews = (config.requiredReviewsPerProject as number) ?? 3
|
||||
const minAssignmentsPerJuror =
|
||||
(config.minLoadPerJuror as number) ??
|
||||
(config.minAssignmentsPerJuror as number) ??
|
||||
1
|
||||
const maxAssignmentsPerJuror =
|
||||
(config.maxLoadPerJuror as number) ??
|
||||
(config.maxAssignmentsPerJuror as number) ??
|
||||
20
|
||||
|
||||
// Scope jurors to jury group if the round has one assigned
|
||||
let scopedJurorIds: string[] | undefined
|
||||
if (round.juryGroupId) {
|
||||
const groupMembers = await prisma.juryGroupMember.findMany({
|
||||
where: { juryGroupId: round.juryGroupId },
|
||||
select: { userId: true },
|
||||
})
|
||||
scopedJurorIds = groupMembers.map((m) => m.userId)
|
||||
}
|
||||
|
||||
const jurors = await prisma.user.findMany({
|
||||
where: {
|
||||
roles: { has: 'JURY_MEMBER' },
|
||||
status: 'ACTIVE',
|
||||
...(scopedJurorIds ? { id: { in: scopedJurorIds } } : {}),
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
email: true,
|
||||
expertiseTags: true,
|
||||
maxAssignments: true,
|
||||
_count: {
|
||||
select: {
|
||||
assignments: { where: { roundId } },
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
const projectRoundStates = await prisma.projectRoundState.findMany({
|
||||
where: { roundId },
|
||||
select: { projectId: true },
|
||||
})
|
||||
const projectIds = projectRoundStates.map((prs) => prs.projectId)
|
||||
|
||||
const projects = await prisma.project.findMany({
|
||||
where: { id: { in: projectIds } },
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
description: true,
|
||||
tags: true,
|
||||
teamName: true,
|
||||
projectTags: {
|
||||
select: { tag: { select: { name: true } }, confidence: true },
|
||||
},
|
||||
_count: { select: { assignments: { where: { roundId } } } },
|
||||
},
|
||||
})
|
||||
|
||||
// Enrich projects with tag confidence data for AI matching
|
||||
const projectsWithConfidence = projects.map((p) => ({
|
||||
...p,
|
||||
tagConfidences: p.projectTags.map((pt) => ({
|
||||
name: pt.tag.name,
|
||||
confidence: pt.confidence,
|
||||
})),
|
||||
}))
|
||||
|
||||
const existingAssignments = await prisma.assignment.findMany({
|
||||
where: { roundId },
|
||||
select: { userId: true, projectId: true },
|
||||
})
|
||||
|
||||
// Query COI records for this round to exclude conflicted juror-project pairs
|
||||
const coiRecords = await prisma.conflictOfInterest.findMany({
|
||||
where: {
|
||||
assignment: { roundId },
|
||||
hasConflict: true,
|
||||
},
|
||||
select: { userId: true, projectId: true },
|
||||
})
|
||||
const coiExclusions = new Set(
|
||||
coiRecords.map((c) => `${c.userId}:${c.projectId}`)
|
||||
)
|
||||
|
||||
// Calculate batch info
|
||||
const BATCH_SIZE = 15
|
||||
const totalBatches = Math.ceil(projects.length / BATCH_SIZE)
|
||||
|
||||
await prisma.assignmentJob.update({
|
||||
where: { id: jobId },
|
||||
data: { totalProjects: projects.length, totalBatches },
|
||||
})
|
||||
|
||||
// Progress callback
|
||||
const onProgress: AssignmentProgressCallback = async (progress) => {
|
||||
await prisma.assignmentJob.update({
|
||||
where: { id: jobId },
|
||||
data: {
|
||||
currentBatch: progress.currentBatch,
|
||||
processedCount: progress.processedCount,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Build per-juror limits map for jurors with personal maxAssignments
|
||||
const jurorLimits: Record<string, number> = {}
|
||||
for (const juror of jurors) {
|
||||
if (juror.maxAssignments !== null && juror.maxAssignments !== undefined) {
|
||||
jurorLimits[juror.id] = juror.maxAssignments
|
||||
}
|
||||
}
|
||||
|
||||
const constraints = {
|
||||
requiredReviewsPerProject: requiredReviews,
|
||||
minAssignmentsPerJuror,
|
||||
maxAssignmentsPerJuror,
|
||||
jurorLimits: Object.keys(jurorLimits).length > 0 ? jurorLimits : undefined,
|
||||
existingAssignments: existingAssignments.map((a) => ({
|
||||
jurorId: a.userId,
|
||||
projectId: a.projectId,
|
||||
})),
|
||||
}
|
||||
|
||||
const result = await generateAIAssignments(
|
||||
jurors,
|
||||
projectsWithConfidence,
|
||||
constraints,
|
||||
userId,
|
||||
roundId,
|
||||
onProgress
|
||||
)
|
||||
|
||||
// Filter out suggestions that conflict with COI declarations
|
||||
const filteredSuggestions = coiExclusions.size > 0
|
||||
? result.suggestions.filter((s) => !coiExclusions.has(`${s.jurorId}:${s.projectId}`))
|
||||
: result.suggestions
|
||||
|
||||
// Enrich suggestions with names for storage
|
||||
const enrichedSuggestions = filteredSuggestions.map((s) => {
|
||||
const juror = jurors.find((j) => j.id === s.jurorId)
|
||||
const project = projects.find((p) => p.id === s.projectId)
|
||||
return {
|
||||
...s,
|
||||
jurorName: juror?.name || juror?.email || 'Unknown',
|
||||
projectTitle: project?.title || 'Unknown',
|
||||
}
|
||||
})
|
||||
|
||||
// Mark job as completed and store suggestions
|
||||
await prisma.assignmentJob.update({
|
||||
where: { id: jobId },
|
||||
data: {
|
||||
status: 'COMPLETED',
|
||||
completedAt: new Date(),
|
||||
processedCount: projects.length,
|
||||
suggestionsCount: filteredSuggestions.length,
|
||||
suggestionsJson: enrichedSuggestions,
|
||||
fallbackUsed: result.fallbackUsed ?? false,
|
||||
},
|
||||
})
|
||||
|
||||
await notifyAdmins({
|
||||
type: NotificationTypes.AI_SUGGESTIONS_READY,
|
||||
title: 'AI Assignment Suggestions Ready',
|
||||
message: `AI generated ${filteredSuggestions.length} assignment suggestions for ${round.name || 'round'}${result.fallbackUsed ? ' (using fallback algorithm)' : ''}.`,
|
||||
linkUrl: `/admin/rounds/${roundId}`,
|
||||
linkLabel: 'View Suggestions',
|
||||
priority: 'high',
|
||||
metadata: {
|
||||
roundId,
|
||||
jobId,
|
||||
projectCount: projects.length,
|
||||
suggestionsCount: filteredSuggestions.length,
|
||||
fallbackUsed: result.fallbackUsed,
|
||||
},
|
||||
})
|
||||
|
||||
} catch (error) {
|
||||
console.error('[AI Assignment Job] Error:', error)
|
||||
|
||||
// Mark job as failed
|
||||
await prisma.assignmentJob.update({
|
||||
where: { id: jobId },
|
||||
data: {
|
||||
status: 'FAILED',
|
||||
errorMessage: error instanceof Error ? error.message : 'Unknown error',
|
||||
completedAt: new Date(),
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
export const assignmentSuggestionsRouter = router({
|
||||
/**
|
||||
* Get smart assignment suggestions using algorithm
|
||||
*/
|
||||
getSuggestions: adminProcedure
|
||||
.input(
|
||||
z.object({
|
||||
roundId: z.string(),
|
||||
})
|
||||
)
|
||||
.query(async ({ ctx, input }) => {
|
||||
const stage = await ctx.prisma.round.findUniqueOrThrow({
|
||||
where: { id: input.roundId },
|
||||
select: { configJson: true, juryGroupId: true },
|
||||
})
|
||||
const config = (stage.configJson ?? {}) as Record<string, unknown>
|
||||
const requiredReviews = (config.requiredReviewsPerProject as number) ?? 3
|
||||
const minAssignmentsPerJuror =
|
||||
(config.minLoadPerJuror as number) ??
|
||||
(config.minAssignmentsPerJuror as number) ??
|
||||
1
|
||||
const maxAssignmentsPerJuror =
|
||||
(config.maxLoadPerJuror as number) ??
|
||||
(config.maxAssignmentsPerJuror as number) ??
|
||||
20
|
||||
|
||||
// Extract category quotas if enabled
|
||||
const categoryQuotasEnabled = config.categoryQuotasEnabled === true
|
||||
const categoryQuotas = categoryQuotasEnabled
|
||||
? (config.categoryQuotas as Record<string, { min: number; max: number }> | undefined)
|
||||
: undefined
|
||||
|
||||
// Scope jurors to jury group if the round has one assigned
|
||||
let scopedJurorIds: string[] | undefined
|
||||
if (stage.juryGroupId) {
|
||||
const groupMembers = await ctx.prisma.juryGroupMember.findMany({
|
||||
where: { juryGroupId: stage.juryGroupId },
|
||||
select: { userId: true },
|
||||
})
|
||||
scopedJurorIds = groupMembers.map((m) => m.userId)
|
||||
}
|
||||
|
||||
const jurors = await ctx.prisma.user.findMany({
|
||||
where: {
|
||||
roles: { has: 'JURY_MEMBER' },
|
||||
status: 'ACTIVE',
|
||||
...(scopedJurorIds ? { id: { in: scopedJurorIds } } : {}),
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
email: true,
|
||||
expertiseTags: true,
|
||||
maxAssignments: true,
|
||||
_count: {
|
||||
select: {
|
||||
assignments: { where: { roundId: input.roundId } },
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
const projectRoundStates = await ctx.prisma.projectRoundState.findMany({
|
||||
where: { roundId: input.roundId },
|
||||
select: { projectId: true },
|
||||
})
|
||||
const projectIds = projectRoundStates.map((pss) => pss.projectId)
|
||||
|
||||
const projects = await ctx.prisma.project.findMany({
|
||||
where: { id: { in: projectIds } },
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
tags: true,
|
||||
competitionCategory: true,
|
||||
projectTags: {
|
||||
include: { tag: { select: { name: true } } },
|
||||
},
|
||||
_count: { select: { assignments: { where: { roundId: input.roundId } } } },
|
||||
},
|
||||
})
|
||||
|
||||
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||||
where: { roundId: input.roundId },
|
||||
select: { userId: true, projectId: true },
|
||||
})
|
||||
const assignmentSet = new Set(
|
||||
existingAssignments.map((a) => `${a.userId}-${a.projectId}`)
|
||||
)
|
||||
|
||||
// Build per-juror category distribution for quota scoring
|
||||
const jurorCategoryDistribution = new Map<string, Record<string, number>>()
|
||||
if (categoryQuotas) {
|
||||
const assignmentsWithCategory = await ctx.prisma.assignment.findMany({
|
||||
where: { roundId: input.roundId },
|
||||
select: {
|
||||
userId: true,
|
||||
project: { select: { competitionCategory: true } },
|
||||
},
|
||||
})
|
||||
for (const a of assignmentsWithCategory) {
|
||||
const cat = a.project.competitionCategory?.toLowerCase().trim()
|
||||
if (!cat) continue
|
||||
let catMap = jurorCategoryDistribution.get(a.userId)
|
||||
if (!catMap) {
|
||||
catMap = {}
|
||||
jurorCategoryDistribution.set(a.userId, catMap)
|
||||
}
|
||||
catMap[cat] = (catMap[cat] || 0) + 1
|
||||
}
|
||||
}
|
||||
|
||||
const suggestions: Array<{
|
||||
userId: string
|
||||
jurorName: string
|
||||
projectId: string
|
||||
projectTitle: string
|
||||
score: number
|
||||
reasoning: string[]
|
||||
}> = []
|
||||
|
||||
for (const project of projects) {
|
||||
if (project._count.assignments >= requiredReviews) continue
|
||||
|
||||
const neededAssignments = requiredReviews - project._count.assignments
|
||||
|
||||
const jurorScores = jurors
|
||||
.filter((j) => {
|
||||
if (assignmentSet.has(`${j.id}-${project.id}`)) return false
|
||||
const effectiveMax = j.maxAssignments ?? maxAssignmentsPerJuror
|
||||
if (j._count.assignments >= effectiveMax) return false
|
||||
return true
|
||||
})
|
||||
.map((juror) => {
|
||||
const reasoning: string[] = []
|
||||
let score = 0
|
||||
|
||||
const projectTagNames = project.projectTags.map((pt) => pt.tag.name.toLowerCase())
|
||||
|
||||
const matchingTags = projectTagNames.length > 0
|
||||
? juror.expertiseTags.filter((tag) =>
|
||||
projectTagNames.includes(tag.toLowerCase())
|
||||
)
|
||||
: juror.expertiseTags.filter((tag) =>
|
||||
project.tags.map((t) => t.toLowerCase()).includes(tag.toLowerCase())
|
||||
)
|
||||
|
||||
const totalTags = projectTagNames.length > 0 ? projectTagNames.length : project.tags.length
|
||||
const expertiseScore =
|
||||
matchingTags.length > 0
|
||||
? matchingTags.length / Math.max(totalTags, 1)
|
||||
: 0
|
||||
score += expertiseScore * 35
|
||||
if (matchingTags.length > 0) {
|
||||
reasoning.push(`Expertise match: ${matchingTags.join(', ')}`)
|
||||
}
|
||||
|
||||
const effectiveMax = juror.maxAssignments ?? maxAssignmentsPerJuror
|
||||
const loadScore = 1 - juror._count.assignments / effectiveMax
|
||||
score += loadScore * 20
|
||||
|
||||
const underMinBonus =
|
||||
juror._count.assignments < minAssignmentsPerJuror
|
||||
? (minAssignmentsPerJuror - juror._count.assignments) * 3
|
||||
: 0
|
||||
score += Math.min(15, underMinBonus)
|
||||
|
||||
if (juror._count.assignments < minAssignmentsPerJuror) {
|
||||
reasoning.push(
|
||||
`Under target: ${juror._count.assignments}/${minAssignmentsPerJuror} min`
|
||||
)
|
||||
}
|
||||
reasoning.push(
|
||||
`Capacity: ${juror._count.assignments}/${effectiveMax} max`
|
||||
)
|
||||
|
||||
// Category quota scoring
|
||||
if (categoryQuotas) {
|
||||
const jurorCategoryCounts = jurorCategoryDistribution.get(juror.id) || {}
|
||||
const normalizedCat = project.competitionCategory?.toLowerCase().trim()
|
||||
if (normalizedCat) {
|
||||
const quota = Object.entries(categoryQuotas).find(
|
||||
([key]) => key.toLowerCase().trim() === normalizedCat
|
||||
)
|
||||
if (quota) {
|
||||
const [, { min, max }] = quota
|
||||
const currentCount = jurorCategoryCounts[normalizedCat] || 0
|
||||
if (currentCount >= max) {
|
||||
score -= 25
|
||||
reasoning.push(`Category quota exceeded (-25)`)
|
||||
} else if (currentCount < min) {
|
||||
const otherAboveMin = Object.entries(categoryQuotas).some(([key, q]) => {
|
||||
if (key.toLowerCase().trim() === normalizedCat) return false
|
||||
return (jurorCategoryCounts[key.toLowerCase().trim()] || 0) >= q.min
|
||||
})
|
||||
if (otherAboveMin) {
|
||||
score += 10
|
||||
reasoning.push(`Category quota bonus (+10)`)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
userId: juror.id,
|
||||
jurorName: juror.name || juror.email || 'Unknown',
|
||||
projectId: project.id,
|
||||
projectTitle: project.title || 'Unknown',
|
||||
score,
|
||||
reasoning,
|
||||
}
|
||||
})
|
||||
.sort((a, b) => b.score - a.score)
|
||||
.slice(0, neededAssignments)
|
||||
|
||||
suggestions.push(...jurorScores)
|
||||
}
|
||||
|
||||
return suggestions.sort((a, b) => b.score - a.score)
|
||||
}),
|
||||
|
||||
/**
|
||||
* Check if AI assignment is available
|
||||
*/
|
||||
isAIAvailable: adminProcedure.query(async () => {
|
||||
return isOpenAIConfigured()
|
||||
}),
|
||||
|
||||
/**
|
||||
* Get AI-powered assignment suggestions (retrieves from completed job)
|
||||
*/
|
||||
getAISuggestions: adminProcedure
|
||||
.input(
|
||||
z.object({
|
||||
roundId: z.string(),
|
||||
useAI: z.boolean().default(true),
|
||||
})
|
||||
)
|
||||
.query(async ({ ctx, input }) => {
|
||||
const completedJob = await ctx.prisma.assignmentJob.findFirst({
|
||||
where: {
|
||||
roundId: input.roundId,
|
||||
status: 'COMPLETED',
|
||||
},
|
||||
orderBy: { completedAt: 'desc' },
|
||||
select: {
|
||||
suggestionsJson: true,
|
||||
fallbackUsed: true,
|
||||
completedAt: true,
|
||||
},
|
||||
})
|
||||
|
||||
if (completedJob?.suggestionsJson) {
|
||||
const suggestions = completedJob.suggestionsJson as Array<{
|
||||
jurorId: string
|
||||
jurorName: string
|
||||
projectId: string
|
||||
projectTitle: string
|
||||
confidenceScore: number
|
||||
expertiseMatchScore: number
|
||||
reasoning: string
|
||||
}>
|
||||
|
||||
const existingAssignments = await ctx.prisma.assignment.findMany({
|
||||
where: { roundId: input.roundId },
|
||||
select: { userId: true, projectId: true },
|
||||
})
|
||||
const assignmentSet = new Set(
|
||||
existingAssignments.map((a) => `${a.userId}-${a.projectId}`)
|
||||
)
|
||||
|
||||
const filteredSuggestions = suggestions.filter(
|
||||
(s) => !assignmentSet.has(`${s.jurorId}-${s.projectId}`)
|
||||
)
|
||||
|
||||
return {
|
||||
success: true,
|
||||
suggestions: filteredSuggestions,
|
||||
fallbackUsed: completedJob.fallbackUsed,
|
||||
error: null,
|
||||
generatedAt: completedJob.completedAt,
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
suggestions: [],
|
||||
fallbackUsed: false,
|
||||
error: null,
|
||||
generatedAt: null,
|
||||
}
|
||||
}),
|
||||
|
||||
/**
|
||||
* Apply AI-suggested assignments
|
||||
*/
|
||||
applyAISuggestions: adminProcedure
|
||||
.input(
|
||||
z.object({
|
||||
roundId: z.string(),
|
||||
assignments: z.array(
|
||||
z.object({
|
||||
userId: z.string(),
|
||||
projectId: z.string(),
|
||||
confidenceScore: z.number().optional(),
|
||||
expertiseMatchScore: z.number().optional(),
|
||||
reasoning: z.string().optional(),
|
||||
})
|
||||
),
|
||||
usedAI: z.boolean().default(false),
|
||||
forceOverride: z.boolean().default(false),
|
||||
})
|
||||
)
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
let assignmentsToCreate = input.assignments
|
||||
let skippedDueToCapacity = 0
|
||||
|
||||
// Capacity check (unless forceOverride)
|
||||
if (!input.forceOverride) {
|
||||
const uniqueUserIds = [...new Set(input.assignments.map((a) => a.userId))]
|
||||
const users = await ctx.prisma.user.findMany({
|
||||
where: { id: { in: uniqueUserIds } },
|
||||
select: {
|
||||
id: true,
|
||||
maxAssignments: true,
|
||||
_count: {
|
||||
select: {
|
||||
assignments: { where: { roundId: input.roundId } },
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
const userMap = new Map(users.map((u) => [u.id, u]))
|
||||
|
||||
const stageData = await ctx.prisma.round.findUniqueOrThrow({
|
||||
where: { id: input.roundId },
|
||||
select: { configJson: true },
|
||||
})
|
||||
const config = (stageData.configJson ?? {}) as Record<string, unknown>
|
||||
const stageMaxPerJuror =
|
||||
(config.maxLoadPerJuror as number) ??
|
||||
(config.maxAssignmentsPerJuror as number) ??
|
||||
20
|
||||
|
||||
const runningCounts = new Map<string, number>()
|
||||
for (const u of users) {
|
||||
runningCounts.set(u.id, u._count.assignments)
|
||||
}
|
||||
|
||||
assignmentsToCreate = input.assignments.filter((a) => {
|
||||
const user = userMap.get(a.userId)
|
||||
if (!user) return true
|
||||
|
||||
const effectiveMax = user.maxAssignments ?? stageMaxPerJuror
|
||||
const currentCount = runningCounts.get(a.userId) ?? 0
|
||||
|
||||
if (currentCount >= effectiveMax) {
|
||||
skippedDueToCapacity++
|
||||
return false
|
||||
}
|
||||
|
||||
runningCounts.set(a.userId, currentCount + 1)
|
||||
return true
|
||||
})
|
||||
}
|
||||
|
||||
const created = await ctx.prisma.assignment.createMany({
|
||||
data: assignmentsToCreate.map((a) => ({
|
||||
userId: a.userId,
|
||||
projectId: a.projectId,
|
||||
roundId: input.roundId,
|
||||
method: input.usedAI ? 'AI_SUGGESTED' : 'ALGORITHM',
|
||||
aiConfidenceScore: a.confidenceScore,
|
||||
expertiseMatchScore: a.expertiseMatchScore,
|
||||
aiReasoning: a.reasoning,
|
||||
createdBy: ctx.user.id,
|
||||
})),
|
||||
skipDuplicates: true,
|
||||
})
|
||||
|
||||
await logAudit({
|
||||
prisma: ctx.prisma,
|
||||
userId: ctx.user.id,
|
||||
action: input.usedAI ? 'APPLY_AI_SUGGESTIONS' : 'APPLY_SUGGESTIONS',
|
||||
entityType: 'Assignment',
|
||||
detailsJson: {
|
||||
roundId: input.roundId,
|
||||
count: created.count,
|
||||
usedAI: input.usedAI,
|
||||
forceOverride: input.forceOverride,
|
||||
skippedDueToCapacity,
|
||||
},
|
||||
ipAddress: ctx.ip,
|
||||
userAgent: ctx.userAgent,
|
||||
})
|
||||
|
||||
if (created.count > 0) {
|
||||
const userAssignmentCounts = assignmentsToCreate.reduce(
|
||||
(acc, a) => {
|
||||
acc[a.userId] = (acc[a.userId] || 0) + 1
|
||||
return acc
|
||||
},
|
||||
{} as Record<string, number>
|
||||
)
|
||||
|
||||
const stage = await ctx.prisma.round.findUnique({
|
||||
where: { id: input.roundId },
|
||||
select: { name: true, windowCloseAt: true },
|
||||
})
|
||||
|
||||
const deadline = stage?.windowCloseAt
|
||||
? new Date(stage.windowCloseAt).toLocaleDateString('en-US', {
|
||||
weekday: 'long',
|
||||
year: 'numeric',
|
||||
month: 'long',
|
||||
day: 'numeric',
|
||||
})
|
||||
: undefined
|
||||
|
||||
await buildBatchNotifications(userAssignmentCounts, stage?.name, deadline)
|
||||
}
|
||||
|
||||
return {
|
||||
created: created.count,
|
||||
requested: input.assignments.length,
|
||||
skippedDueToCapacity,
|
||||
}
|
||||
}),
|
||||
|
||||
/**
|
||||
* Apply suggested assignments
|
||||
*/
|
||||
applySuggestions: adminProcedure
|
||||
.input(
|
||||
z.object({
|
||||
roundId: z.string(),
|
||||
assignments: z.array(
|
||||
z.object({
|
||||
userId: z.string(),
|
||||
projectId: z.string(),
|
||||
reasoning: z.string().optional(),
|
||||
})
|
||||
),
|
||||
forceOverride: z.boolean().default(false),
|
||||
})
|
||||
)
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
let assignmentsToCreate = input.assignments
|
||||
let skippedDueToCapacity = 0
|
||||
|
||||
// Capacity check (unless forceOverride)
|
||||
if (!input.forceOverride) {
|
||||
const uniqueUserIds = [...new Set(input.assignments.map((a) => a.userId))]
|
||||
const users = await ctx.prisma.user.findMany({
|
||||
where: { id: { in: uniqueUserIds } },
|
||||
select: {
|
||||
id: true,
|
||||
maxAssignments: true,
|
||||
_count: {
|
||||
select: {
|
||||
assignments: { where: { roundId: input.roundId } },
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
const userMap = new Map(users.map((u) => [u.id, u]))
|
||||
|
||||
const stageData = await ctx.prisma.round.findUniqueOrThrow({
|
||||
where: { id: input.roundId },
|
||||
select: { configJson: true },
|
||||
})
|
||||
const config = (stageData.configJson ?? {}) as Record<string, unknown>
|
||||
const stageMaxPerJuror =
|
||||
(config.maxLoadPerJuror as number) ??
|
||||
(config.maxAssignmentsPerJuror as number) ??
|
||||
20
|
||||
|
||||
const runningCounts = new Map<string, number>()
|
||||
for (const u of users) {
|
||||
runningCounts.set(u.id, u._count.assignments)
|
||||
}
|
||||
|
||||
assignmentsToCreate = input.assignments.filter((a) => {
|
||||
const user = userMap.get(a.userId)
|
||||
if (!user) return true
|
||||
|
||||
const effectiveMax = user.maxAssignments ?? stageMaxPerJuror
|
||||
const currentCount = runningCounts.get(a.userId) ?? 0
|
||||
|
||||
if (currentCount >= effectiveMax) {
|
||||
skippedDueToCapacity++
|
||||
return false
|
||||
}
|
||||
|
||||
runningCounts.set(a.userId, currentCount + 1)
|
||||
return true
|
||||
})
|
||||
}
|
||||
|
||||
const created = await ctx.prisma.assignment.createMany({
|
||||
data: assignmentsToCreate.map((a) => ({
|
||||
userId: a.userId,
|
||||
projectId: a.projectId,
|
||||
roundId: input.roundId,
|
||||
method: 'ALGORITHM',
|
||||
aiReasoning: a.reasoning,
|
||||
createdBy: ctx.user.id,
|
||||
})),
|
||||
skipDuplicates: true,
|
||||
})
|
||||
|
||||
await logAudit({
|
||||
prisma: ctx.prisma,
|
||||
userId: ctx.user.id,
|
||||
action: 'APPLY_SUGGESTIONS',
|
||||
entityType: 'Assignment',
|
||||
detailsJson: {
|
||||
roundId: input.roundId,
|
||||
count: created.count,
|
||||
forceOverride: input.forceOverride,
|
||||
skippedDueToCapacity,
|
||||
},
|
||||
ipAddress: ctx.ip,
|
||||
userAgent: ctx.userAgent,
|
||||
})
|
||||
|
||||
if (created.count > 0) {
|
||||
const userAssignmentCounts = assignmentsToCreate.reduce(
|
||||
(acc, a) => {
|
||||
acc[a.userId] = (acc[a.userId] || 0) + 1
|
||||
return acc
|
||||
},
|
||||
{} as Record<string, number>
|
||||
)
|
||||
|
||||
const stage = await ctx.prisma.round.findUnique({
|
||||
where: { id: input.roundId },
|
||||
select: { name: true, windowCloseAt: true },
|
||||
})
|
||||
|
||||
const deadline = stage?.windowCloseAt
|
||||
? new Date(stage.windowCloseAt).toLocaleDateString('en-US', {
|
||||
weekday: 'long',
|
||||
year: 'numeric',
|
||||
month: 'long',
|
||||
day: 'numeric',
|
||||
})
|
||||
: undefined
|
||||
|
||||
await buildBatchNotifications(userAssignmentCounts, stage?.name, deadline)
|
||||
}
|
||||
|
||||
return {
|
||||
created: created.count,
|
||||
requested: input.assignments.length,
|
||||
skippedDueToCapacity,
|
||||
}
|
||||
}),
|
||||
|
||||
/**
|
||||
* Start an AI assignment job (background processing)
|
||||
*/
|
||||
startAIAssignmentJob: adminProcedure
|
||||
.use(withAIRateLimit)
|
||||
.input(z.object({ roundId: z.string() }))
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
const existingJob = await ctx.prisma.assignmentJob.findFirst({
|
||||
where: {
|
||||
roundId: input.roundId,
|
||||
status: { in: ['PENDING', 'RUNNING'] },
|
||||
},
|
||||
})
|
||||
|
||||
if (existingJob) {
|
||||
throw new TRPCError({
|
||||
code: 'BAD_REQUEST',
|
||||
message: 'An AI assignment job is already running for this stage',
|
||||
})
|
||||
}
|
||||
|
||||
if (!isOpenAIConfigured()) {
|
||||
throw new TRPCError({
|
||||
code: 'BAD_REQUEST',
|
||||
message: 'OpenAI API is not configured',
|
||||
})
|
||||
}
|
||||
|
||||
const job = await ctx.prisma.assignmentJob.create({
|
||||
data: {
|
||||
roundId: input.roundId,
|
||||
status: 'PENDING',
|
||||
},
|
||||
})
|
||||
|
||||
runAIAssignmentJob(job.id, input.roundId, ctx.user.id).catch(console.error)
|
||||
|
||||
return { jobId: job.id }
|
||||
}),
|
||||
|
||||
/**
|
||||
* Get AI assignment job status (for polling)
|
||||
*/
|
||||
getAIAssignmentJobStatus: adminProcedure
|
||||
.input(z.object({ jobId: z.string() }))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const job = await ctx.prisma.assignmentJob.findUniqueOrThrow({
|
||||
where: { id: input.jobId },
|
||||
})
|
||||
|
||||
return {
|
||||
id: job.id,
|
||||
status: job.status,
|
||||
totalProjects: job.totalProjects,
|
||||
totalBatches: job.totalBatches,
|
||||
currentBatch: job.currentBatch,
|
||||
processedCount: job.processedCount,
|
||||
suggestionsCount: job.suggestionsCount,
|
||||
fallbackUsed: job.fallbackUsed,
|
||||
errorMessage: job.errorMessage,
|
||||
startedAt: job.startedAt,
|
||||
completedAt: job.completedAt,
|
||||
}
|
||||
}),
|
||||
|
||||
/**
|
||||
* Get the latest AI assignment job for a round
|
||||
*/
|
||||
getLatestAIAssignmentJob: adminProcedure
|
||||
.input(z.object({ roundId: z.string() }))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const job = await ctx.prisma.assignmentJob.findFirst({
|
||||
where: { roundId: input.roundId },
|
||||
orderBy: { createdAt: 'desc' },
|
||||
})
|
||||
|
||||
if (!job) return null
|
||||
|
||||
return {
|
||||
id: job.id,
|
||||
status: job.status,
|
||||
totalProjects: job.totalProjects,
|
||||
totalBatches: job.totalBatches,
|
||||
currentBatch: job.currentBatch,
|
||||
processedCount: job.processedCount,
|
||||
suggestionsCount: job.suggestionsCount,
|
||||
fallbackUsed: job.fallbackUsed,
|
||||
errorMessage: job.errorMessage,
|
||||
startedAt: job.startedAt,
|
||||
completedAt: job.completedAt,
|
||||
createdAt: job.createdAt,
|
||||
}
|
||||
}),
|
||||
})
|
||||
Reference in New Issue
Block a user