feat: round finalization with ranking-based outcomes + award pool notifications
All checks were successful
Build and Push Docker Image / build (push) Successful in 10m0s
All checks were successful
Build and Push Docker Image / build (push) Successful in 10m0s
- processRoundClose EVALUATION uses ranking scores + advanceMode config (threshold vs count) to auto-set proposedOutcome instead of defaulting all to PASSED - Advancement emails generate invite tokens for passwordless users with "Create Your Account" CTA; rejection emails have no link - Finalization UI shows account stats (invite vs dashboard link counts) - Fixed getFinalizationSummary ranking query (was using non-existent rankingsJson) - New award pool notification system: getAwardSelectionNotificationTemplate email, notifyEligibleProjects mutation with invite token generation, "Notify Pool" button on award detail page with custom message dialog Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
830
src/server/services/round-finalization.ts
Normal file
830
src/server/services/round-finalization.ts
Normal file
@@ -0,0 +1,830 @@
|
||||
/**
|
||||
* Round Finalization Service
|
||||
*
|
||||
* Handles the post-close lifecycle of a round:
|
||||
* - processRoundClose: auto-sets project states after a round closes
|
||||
* - getFinalizationSummary: aggregates data for the finalization review UI
|
||||
* - confirmFinalization: single transaction to apply outcomes, advance projects, send emails
|
||||
*/
|
||||
|
||||
import type { PrismaClient, ProjectRoundStateValue, RoundType, Prisma } from '@prisma/client'
|
||||
import { transitionProject, isTerminalState } from './round-engine'
|
||||
import { logAudit } from '@/server/utils/audit'
|
||||
import {
|
||||
sendStyledNotificationEmail,
|
||||
getRejectionNotificationTemplate,
|
||||
} from '@/lib/email'
|
||||
import { createBulkNotifications } from '../services/in-app-notification'
|
||||
import { generateInviteToken, getInviteExpiryMs } from '@/server/utils/invite'
|
||||
|
||||
// ─── Types ──────────────────────────────────────────────────────────────────
|
||||
|
||||
export type FinalizationSummary = {
|
||||
roundId: string
|
||||
roundName: string
|
||||
roundType: RoundType
|
||||
isGracePeriodActive: boolean
|
||||
gracePeriodEndsAt: Date | null
|
||||
isFinalized: boolean
|
||||
finalizedAt: Date | null
|
||||
stats: {
|
||||
pending: number
|
||||
inProgress: number
|
||||
completed: number
|
||||
passed: number
|
||||
rejected: number
|
||||
withdrawn: number
|
||||
}
|
||||
projects: Array<{
|
||||
id: string
|
||||
title: string
|
||||
teamName: string | null
|
||||
category: string | null
|
||||
country: string | null
|
||||
currentState: ProjectRoundStateValue
|
||||
proposedOutcome: ProjectRoundStateValue | null
|
||||
evaluationScore?: number | null
|
||||
rankPosition?: number | null
|
||||
}>
|
||||
categoryTargets: {
|
||||
startupTarget: number | null
|
||||
conceptTarget: number | null
|
||||
startupProposed: number
|
||||
conceptProposed: number
|
||||
}
|
||||
nextRound: { id: string; name: string } | null
|
||||
accountStats: {
|
||||
needsInvite: number
|
||||
hasAccount: number
|
||||
}
|
||||
}
|
||||
|
||||
export type ConfirmFinalizationResult = {
|
||||
advanced: number
|
||||
rejected: number
|
||||
emailsSent: number
|
||||
emailsFailed: number
|
||||
}
|
||||
|
||||
// ─── processRoundClose ──────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Process project states after a round closes.
|
||||
* Auto-transitions projects to COMPLETED/REJECTED and sets proposedOutcome defaults.
|
||||
* Called immediately on close (if no grace period) or after grace period expires.
|
||||
*/
|
||||
export async function processRoundClose(
|
||||
roundId: string,
|
||||
actorId: string,
|
||||
prisma: PrismaClient | any,
|
||||
): Promise<{ processed: number }> {
|
||||
const round = await prisma.round.findUnique({
|
||||
where: { id: roundId },
|
||||
include: {
|
||||
competition: {
|
||||
select: {
|
||||
rounds: {
|
||||
select: { id: true, name: true, sortOrder: true },
|
||||
orderBy: { sortOrder: 'asc' as const },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
if (!round) throw new Error(`Round ${roundId} not found`)
|
||||
|
||||
const projectStates = await prisma.projectRoundState.findMany({
|
||||
where: { roundId },
|
||||
include: {
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
competitionCategory: true,
|
||||
files: { where: { roundId }, select: { id: true, requirementId: true, submissionFileRequirementId: true } },
|
||||
assignments: { where: { roundId }, select: { isCompleted: true } },
|
||||
filteringResults: { where: { roundId }, select: { outcome: true, finalOutcome: true } },
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
let processed = 0
|
||||
|
||||
// Pre-compute pass set for EVALUATION rounds using ranking scores + config
|
||||
let evaluationPassSet: Set<string> | null = null
|
||||
if ((round.roundType as RoundType) === 'EVALUATION') {
|
||||
evaluationPassSet = new Set<string>()
|
||||
const snapshot = await prisma.rankingSnapshot.findFirst({
|
||||
where: { roundId },
|
||||
orderBy: { createdAt: 'desc' as const },
|
||||
select: { startupRankingJson: true, conceptRankingJson: true },
|
||||
})
|
||||
if (snapshot) {
|
||||
const config = (round.configJson as Record<string, unknown>) ?? {}
|
||||
const advanceMode = (config.advanceMode as string) || 'count'
|
||||
const advanceScoreThreshold = (config.advanceScoreThreshold as number) ?? 6
|
||||
const startupAdvanceCount = (config.startupAdvanceCount as number) ?? 0
|
||||
const conceptAdvanceCount = (config.conceptAdvanceCount as number) ?? 0
|
||||
|
||||
type RankEntry = { projectId: string; avgGlobalScore: number | null; rank: number }
|
||||
const startupRanked = (snapshot.startupRankingJson ?? []) as RankEntry[]
|
||||
const conceptRanked = (snapshot.conceptRankingJson ?? []) as RankEntry[]
|
||||
|
||||
if (advanceMode === 'threshold') {
|
||||
for (const r of [...startupRanked, ...conceptRanked]) {
|
||||
if (r.avgGlobalScore != null && r.avgGlobalScore >= advanceScoreThreshold) {
|
||||
evaluationPassSet.add(r.projectId)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// 'count' mode — top N per category by rank
|
||||
const sortedStartup = [...startupRanked].sort((a, b) => a.rank - b.rank)
|
||||
const sortedConcept = [...conceptRanked].sort((a, b) => a.rank - b.rank)
|
||||
for (let i = 0; i < Math.min(startupAdvanceCount, sortedStartup.length); i++) {
|
||||
evaluationPassSet.add(sortedStartup[i].projectId)
|
||||
}
|
||||
for (let i = 0; i < Math.min(conceptAdvanceCount, sortedConcept.length); i++) {
|
||||
evaluationPassSet.add(sortedConcept[i].projectId)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (const prs of projectStates) {
|
||||
// Skip already-terminal states
|
||||
if (isTerminalState(prs.state)) {
|
||||
// Set proposed outcome to match current state for display
|
||||
if (!prs.proposedOutcome) {
|
||||
await prisma.projectRoundState.update({
|
||||
where: { id: prs.id },
|
||||
data: { proposedOutcome: prs.state },
|
||||
})
|
||||
}
|
||||
processed++
|
||||
continue
|
||||
}
|
||||
|
||||
let targetState: ProjectRoundStateValue = prs.state
|
||||
let proposedOutcome: ProjectRoundStateValue = 'PASSED'
|
||||
|
||||
switch (round.roundType as RoundType) {
|
||||
case 'INTAKE':
|
||||
case 'SUBMISSION': {
|
||||
// Projects with activity → COMPLETED, purely PENDING → REJECTED
|
||||
if (prs.state === 'PENDING') {
|
||||
targetState = 'REJECTED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'REJECTED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'IN_PROGRESS' || prs.state === 'COMPLETED') {
|
||||
if (prs.state === 'IN_PROGRESS') targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'EVALUATION': {
|
||||
// Use ranking scores to determine pass/reject
|
||||
const hasEvals = prs.project.assignments.some((a: { isCompleted: boolean }) => a.isCompleted)
|
||||
const shouldPass = evaluationPassSet?.has(prs.projectId) ?? false
|
||||
if (prs.state === 'IN_PROGRESS' || (prs.state === 'PENDING' && hasEvals)) {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = (shouldPass ? 'PASSED' : 'REJECTED') as ProjectRoundStateValue
|
||||
} else if (prs.state === 'PENDING') {
|
||||
targetState = 'REJECTED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'REJECTED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'COMPLETED') {
|
||||
proposedOutcome = (shouldPass ? 'PASSED' : 'REJECTED') as ProjectRoundStateValue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'FILTERING': {
|
||||
// Use FilteringResult to determine outcome for each project
|
||||
const fr = prs.project.filteringResults?.[0] as { outcome: string; finalOutcome: string | null } | undefined
|
||||
const effectiveOutcome = fr?.finalOutcome || fr?.outcome
|
||||
const filterPassed = effectiveOutcome !== 'FILTERED_OUT'
|
||||
|
||||
if (prs.state === 'COMPLETED') {
|
||||
proposedOutcome = (filterPassed ? 'PASSED' : 'REJECTED') as ProjectRoundStateValue
|
||||
} else if (prs.state === 'IN_PROGRESS') {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = (filterPassed ? 'PASSED' : 'REJECTED') as ProjectRoundStateValue
|
||||
} else if (prs.state === 'PENDING') {
|
||||
// PENDING projects in filtering: check FilteringResult
|
||||
if (fr) {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = (filterPassed ? 'PASSED' : 'REJECTED') as ProjectRoundStateValue
|
||||
} else {
|
||||
// No filtering result at all → reject
|
||||
targetState = 'REJECTED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'REJECTED' as ProjectRoundStateValue
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'MENTORING': {
|
||||
// Projects already PASSED (pass-through) stay PASSED
|
||||
if (prs.state === 'PASSED') {
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'IN_PROGRESS') {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'COMPLETED') {
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'PENDING') {
|
||||
// Pending = never requested mentoring, pass through
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'LIVE_FINAL': {
|
||||
// All presented projects → COMPLETED
|
||||
if (prs.state === 'IN_PROGRESS' || prs.state === 'PENDING') {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'COMPLETED') {
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'DELIBERATION': {
|
||||
// All voted projects → COMPLETED
|
||||
if (prs.state === 'IN_PROGRESS' || prs.state === 'PENDING') {
|
||||
targetState = 'COMPLETED' as ProjectRoundStateValue
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
} else if (prs.state === 'COMPLETED') {
|
||||
proposedOutcome = 'PASSED' as ProjectRoundStateValue
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Transition project if needed (admin override for non-standard paths)
|
||||
if (targetState !== prs.state && !isTerminalState(prs.state)) {
|
||||
// Need to handle multi-step transitions
|
||||
if (prs.state === 'PENDING' && targetState === 'COMPLETED') {
|
||||
await transitionProject(prs.projectId, roundId, 'IN_PROGRESS' as ProjectRoundStateValue, actorId, prisma, { adminOverride: true })
|
||||
await transitionProject(prs.projectId, roundId, 'COMPLETED' as ProjectRoundStateValue, actorId, prisma, { adminOverride: true })
|
||||
} else if (prs.state === 'PENDING' && targetState === 'REJECTED') {
|
||||
await transitionProject(prs.projectId, roundId, targetState, actorId, prisma, { adminOverride: true })
|
||||
} else {
|
||||
await transitionProject(prs.projectId, roundId, targetState, actorId, prisma, { adminOverride: true })
|
||||
}
|
||||
}
|
||||
|
||||
// Set proposed outcome
|
||||
await prisma.projectRoundState.update({
|
||||
where: { id: prs.id },
|
||||
data: { proposedOutcome },
|
||||
})
|
||||
|
||||
processed++
|
||||
}
|
||||
|
||||
return { processed }
|
||||
}
|
||||
|
||||
// ─── getFinalizationSummary ─────────────────────────────────────────────────
|
||||
|
||||
export async function getFinalizationSummary(
|
||||
roundId: string,
|
||||
prisma: PrismaClient | any,
|
||||
): Promise<FinalizationSummary> {
|
||||
const round = await prisma.round.findUniqueOrThrow({
|
||||
where: { id: roundId },
|
||||
include: {
|
||||
competition: {
|
||||
select: {
|
||||
rounds: {
|
||||
select: { id: true, name: true, sortOrder: true },
|
||||
orderBy: { sortOrder: 'asc' as const },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
const now = new Date()
|
||||
const isGracePeriodActive = !!(round.gracePeriodEndsAt && new Date(round.gracePeriodEndsAt) > now && !round.finalizedAt)
|
||||
const isFinalized = !!round.finalizedAt
|
||||
|
||||
// Get config for category targets
|
||||
const config = (round.configJson as Record<string, unknown>) ?? {}
|
||||
|
||||
// Find next round
|
||||
const rounds = round.competition.rounds
|
||||
const currentIdx = rounds.findIndex((r: { id: string }) => r.id === roundId)
|
||||
const nextRound = currentIdx >= 0 && currentIdx < rounds.length - 1
|
||||
? rounds[currentIdx + 1]
|
||||
: null
|
||||
|
||||
// Get all project states with project details
|
||||
const projectStates = await prisma.projectRoundState.findMany({
|
||||
where: { roundId },
|
||||
include: {
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
teamName: true,
|
||||
competitionCategory: true,
|
||||
country: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: { createdAt: 'asc' as const },
|
||||
})
|
||||
|
||||
// Compute stats
|
||||
const stats = { pending: 0, inProgress: 0, completed: 0, passed: 0, rejected: 0, withdrawn: 0 }
|
||||
for (const prs of projectStates) {
|
||||
switch (prs.state) {
|
||||
case 'PENDING': stats.pending++; break
|
||||
case 'IN_PROGRESS': stats.inProgress++; break
|
||||
case 'COMPLETED': stats.completed++; break
|
||||
case 'PASSED': stats.passed++; break
|
||||
case 'REJECTED': stats.rejected++; break
|
||||
case 'WITHDRAWN': stats.withdrawn++; break
|
||||
}
|
||||
}
|
||||
|
||||
// Get evaluation scores if this is an evaluation round
|
||||
let scoreMap = new Map<string, number>()
|
||||
let rankMap = new Map<string, number>()
|
||||
|
||||
if (round.roundType === 'EVALUATION') {
|
||||
// Get latest ranking snapshot (per-category fields)
|
||||
const snapshot = await prisma.rankingSnapshot.findFirst({
|
||||
where: { roundId },
|
||||
orderBy: { createdAt: 'desc' as const },
|
||||
select: { startupRankingJson: true, conceptRankingJson: true },
|
||||
})
|
||||
if (snapshot) {
|
||||
type RankEntry = { projectId: string; avgGlobalScore?: number; compositeScore?: number; rank?: number }
|
||||
const allRanked = [
|
||||
...((snapshot.startupRankingJson ?? []) as RankEntry[]),
|
||||
...((snapshot.conceptRankingJson ?? []) as RankEntry[]),
|
||||
]
|
||||
for (const r of allRanked) {
|
||||
if (r.avgGlobalScore != null) scoreMap.set(r.projectId, r.avgGlobalScore)
|
||||
else if (r.compositeScore != null) scoreMap.set(r.projectId, r.compositeScore)
|
||||
if (r.rank != null) rankMap.set(r.projectId, r.rank)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Build project list
|
||||
const projects = projectStates.map((prs: any) => ({
|
||||
id: prs.project.id,
|
||||
title: prs.project.title,
|
||||
teamName: prs.project.teamName,
|
||||
category: prs.project.competitionCategory,
|
||||
country: prs.project.country,
|
||||
currentState: prs.state as ProjectRoundStateValue,
|
||||
proposedOutcome: prs.proposedOutcome as ProjectRoundStateValue | null,
|
||||
evaluationScore: scoreMap.get(prs.project.id) ?? null,
|
||||
rankPosition: rankMap.get(prs.project.id) ?? null,
|
||||
}))
|
||||
|
||||
// Category target progress
|
||||
const startupTarget = (config.startupAdvanceCount as number | undefined) ?? null
|
||||
const conceptTarget = (config.conceptAdvanceCount as number | undefined) ?? null
|
||||
|
||||
let startupProposed = 0
|
||||
let conceptProposed = 0
|
||||
for (const p of projects) {
|
||||
if (p.proposedOutcome === 'PASSED') {
|
||||
if (p.category === 'STARTUP') startupProposed++
|
||||
else if (p.category === 'BUSINESS_CONCEPT') conceptProposed++
|
||||
}
|
||||
}
|
||||
|
||||
// Account stats: count how many advancing projects need invite vs already have accounts
|
||||
let needsInvite = 0
|
||||
let hasAccount = 0
|
||||
const passedProjectIds = projects.filter((p: { proposedOutcome: string | null }) => p.proposedOutcome === 'PASSED').map((p: { id: string }) => p.id)
|
||||
if (passedProjectIds.length > 0) {
|
||||
const passedProjects = await prisma.project.findMany({
|
||||
where: { id: { in: passedProjectIds } },
|
||||
select: {
|
||||
id: true,
|
||||
submittedBy: { select: { passwordHash: true } },
|
||||
teamMembers: { select: { user: { select: { passwordHash: true } } } },
|
||||
},
|
||||
})
|
||||
for (const p of passedProjects) {
|
||||
// Check team members first, then submittedBy
|
||||
const users = p.teamMembers.length > 0
|
||||
? p.teamMembers.map((tm: any) => tm.user)
|
||||
: p.submittedBy ? [p.submittedBy] : []
|
||||
const anyHasPassword = users.some((u: any) => !!u.passwordHash)
|
||||
if (anyHasPassword) hasAccount++
|
||||
else needsInvite++
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
roundId,
|
||||
roundName: round.name,
|
||||
roundType: round.roundType,
|
||||
isGracePeriodActive,
|
||||
gracePeriodEndsAt: round.gracePeriodEndsAt,
|
||||
isFinalized,
|
||||
finalizedAt: round.finalizedAt,
|
||||
stats,
|
||||
projects,
|
||||
categoryTargets: {
|
||||
startupTarget,
|
||||
conceptTarget,
|
||||
startupProposed,
|
||||
conceptProposed,
|
||||
},
|
||||
nextRound: nextRound ? { id: nextRound.id, name: nextRound.name } : null,
|
||||
accountStats: { needsInvite, hasAccount },
|
||||
}
|
||||
}
|
||||
|
||||
// ─── confirmFinalization ────────────────────────────────────────────────────
|
||||
|
||||
export async function confirmFinalization(
|
||||
roundId: string,
|
||||
options: {
|
||||
targetRoundId?: string
|
||||
advancementMessage?: string
|
||||
rejectionMessage?: string
|
||||
},
|
||||
actorId: string,
|
||||
prisma: PrismaClient | any,
|
||||
): Promise<ConfirmFinalizationResult> {
|
||||
// Validate: round is CLOSED, not already finalized, grace period expired
|
||||
const round = await prisma.round.findUniqueOrThrow({
|
||||
where: { id: roundId },
|
||||
include: {
|
||||
competition: {
|
||||
select: {
|
||||
id: true,
|
||||
rounds: {
|
||||
select: { id: true, name: true, sortOrder: true },
|
||||
orderBy: { sortOrder: 'asc' as const },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
if (round.status !== 'ROUND_CLOSED') {
|
||||
throw new Error(`Round must be ROUND_CLOSED to finalize, got ${round.status}`)
|
||||
}
|
||||
|
||||
if (round.finalizedAt) {
|
||||
throw new Error('Round is already finalized')
|
||||
}
|
||||
|
||||
const now = new Date()
|
||||
if (round.gracePeriodEndsAt && new Date(round.gracePeriodEndsAt) > now) {
|
||||
throw new Error('Cannot finalize: grace period is still active')
|
||||
}
|
||||
|
||||
// Determine target round
|
||||
const rounds = round.competition.rounds
|
||||
const currentIdx = rounds.findIndex((r: { id: string }) => r.id === roundId)
|
||||
const targetRoundId = options.targetRoundId
|
||||
?? (currentIdx >= 0 && currentIdx < rounds.length - 1
|
||||
? rounds[currentIdx + 1].id
|
||||
: undefined)
|
||||
|
||||
const targetRoundName = targetRoundId
|
||||
? rounds.find((r: { id: string }) => r.id === targetRoundId)?.name ?? 'Next Round'
|
||||
: 'Next Round'
|
||||
|
||||
// Execute finalization in a transaction
|
||||
const result = await prisma.$transaction(async (tx: any) => {
|
||||
const projectStates = await tx.projectRoundState.findMany({
|
||||
where: { roundId, proposedOutcome: { not: null } },
|
||||
include: {
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
status: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
let advanced = 0
|
||||
let rejected = 0
|
||||
|
||||
for (const prs of projectStates) {
|
||||
const proposed = prs.proposedOutcome as ProjectRoundStateValue
|
||||
|
||||
// Skip if already in the proposed state
|
||||
if (prs.state === proposed) {
|
||||
if (proposed === 'PASSED') advanced++
|
||||
else if (proposed === 'REJECTED') rejected++
|
||||
continue
|
||||
}
|
||||
|
||||
// Transition to proposed outcome
|
||||
if (proposed === 'PASSED' || proposed === 'REJECTED') {
|
||||
// Ensure we're in COMPLETED before transitioning to PASSED/REJECTED
|
||||
if (prs.state !== 'COMPLETED' && prs.state !== 'PASSED' && prs.state !== 'REJECTED') {
|
||||
// Force through intermediate states
|
||||
if (prs.state === 'PENDING') {
|
||||
await tx.projectRoundState.update({
|
||||
where: { id: prs.id },
|
||||
data: { state: 'IN_PROGRESS' },
|
||||
})
|
||||
}
|
||||
if (prs.state === 'PENDING' || prs.state === 'IN_PROGRESS') {
|
||||
await tx.projectRoundState.update({
|
||||
where: { id: prs.id },
|
||||
data: { state: 'COMPLETED' },
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Now transition to final state
|
||||
await tx.projectRoundState.update({
|
||||
where: { id: prs.id },
|
||||
data: {
|
||||
state: proposed,
|
||||
exitedAt: now,
|
||||
},
|
||||
})
|
||||
|
||||
if (proposed === 'PASSED') {
|
||||
advanced++
|
||||
|
||||
// Create ProjectRoundState in target round (if exists)
|
||||
if (targetRoundId) {
|
||||
await tx.projectRoundState.upsert({
|
||||
where: {
|
||||
projectId_roundId: {
|
||||
projectId: prs.projectId,
|
||||
roundId: targetRoundId,
|
||||
},
|
||||
},
|
||||
create: {
|
||||
projectId: prs.projectId,
|
||||
roundId: targetRoundId,
|
||||
state: 'PENDING',
|
||||
enteredAt: now,
|
||||
},
|
||||
update: {}, // skip if already exists
|
||||
})
|
||||
}
|
||||
|
||||
// Update Project.status to ASSIGNED
|
||||
await tx.project.update({
|
||||
where: { id: prs.projectId },
|
||||
data: { status: 'ASSIGNED' },
|
||||
})
|
||||
|
||||
// Create ProjectStatusHistory
|
||||
await tx.projectStatusHistory.create({
|
||||
data: {
|
||||
projectId: prs.projectId,
|
||||
status: 'ASSIGNED',
|
||||
changedBy: actorId,
|
||||
reason: `Advanced from round "${round.name}" via finalization`,
|
||||
},
|
||||
})
|
||||
} else {
|
||||
rejected++
|
||||
}
|
||||
|
||||
// Audit log per project
|
||||
await tx.decisionAuditLog.create({
|
||||
data: {
|
||||
eventType: 'finalization.project_outcome',
|
||||
entityType: 'ProjectRoundState',
|
||||
entityId: prs.id,
|
||||
actorId,
|
||||
detailsJson: {
|
||||
projectId: prs.projectId,
|
||||
roundId,
|
||||
previousState: prs.state,
|
||||
outcome: proposed,
|
||||
targetRoundId: proposed === 'PASSED' ? targetRoundId : null,
|
||||
} as Prisma.InputJsonValue,
|
||||
snapshotJson: {
|
||||
timestamp: now.toISOString(),
|
||||
emittedBy: 'round-finalization',
|
||||
},
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Mark round as finalized
|
||||
await tx.round.update({
|
||||
where: { id: roundId },
|
||||
data: {
|
||||
finalizedAt: now,
|
||||
finalizedBy: actorId,
|
||||
},
|
||||
})
|
||||
|
||||
// Finalization audit
|
||||
await tx.decisionAuditLog.create({
|
||||
data: {
|
||||
eventType: 'round.finalized',
|
||||
entityType: 'Round',
|
||||
entityId: roundId,
|
||||
actorId,
|
||||
detailsJson: {
|
||||
roundName: round.name,
|
||||
advanced,
|
||||
rejected,
|
||||
targetRoundId,
|
||||
hasCustomAdvancementMessage: !!options.advancementMessage,
|
||||
hasCustomRejectionMessage: !!options.rejectionMessage,
|
||||
} as Prisma.InputJsonValue,
|
||||
snapshotJson: {
|
||||
timestamp: now.toISOString(),
|
||||
emittedBy: 'round-finalization',
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
return { advanced, rejected }
|
||||
})
|
||||
|
||||
// Send emails outside transaction (non-fatal)
|
||||
let emailsSent = 0
|
||||
let emailsFailed = 0
|
||||
|
||||
try {
|
||||
// Get all projects that were finalized
|
||||
const finalizedStates = await prisma.projectRoundState.findMany({
|
||||
where: { roundId, state: { in: ['PASSED', 'REJECTED'] } },
|
||||
include: {
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
submittedByEmail: true,
|
||||
submittedByUserId: true,
|
||||
submittedBy: { select: { id: true, email: true, name: true, passwordHash: true } },
|
||||
teamMembers: {
|
||||
select: { user: { select: { id: true, email: true, name: true, passwordHash: true } } },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
// Pre-generate invite tokens for passwordless users on advancing projects
|
||||
const inviteTokenMap = new Map<string, string>() // userId → token
|
||||
const expiryMs = await getInviteExpiryMs(prisma)
|
||||
|
||||
for (const prs of finalizedStates) {
|
||||
if (prs.state !== 'PASSED') continue
|
||||
const users = prs.project.teamMembers.length > 0
|
||||
? prs.project.teamMembers.map((tm: any) => tm.user)
|
||||
: prs.project.submittedBy ? [prs.project.submittedBy] : []
|
||||
for (const user of users) {
|
||||
if (user && !user.passwordHash && !inviteTokenMap.has(user.id)) {
|
||||
const token = generateInviteToken()
|
||||
inviteTokenMap.set(user.id, token)
|
||||
await prisma.user.update({
|
||||
where: { id: user.id },
|
||||
data: {
|
||||
inviteToken: token,
|
||||
inviteTokenExpiresAt: new Date(Date.now() + expiryMs),
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const advancedUserIds = new Set<string>()
|
||||
const rejectedUserIds = new Set<string>()
|
||||
|
||||
for (const prs of finalizedStates) {
|
||||
type Recipient = { email: string; name: string | null; userId: string | null }
|
||||
const recipients: Recipient[] = []
|
||||
for (const tm of prs.project.teamMembers) {
|
||||
if (tm.user.email) {
|
||||
recipients.push({ email: tm.user.email, name: tm.user.name, userId: tm.user.id })
|
||||
if (prs.state === 'PASSED') advancedUserIds.add(tm.user.id)
|
||||
else rejectedUserIds.add(tm.user.id)
|
||||
}
|
||||
}
|
||||
if (recipients.length === 0 && prs.project.submittedBy?.email) {
|
||||
recipients.push({
|
||||
email: prs.project.submittedBy.email,
|
||||
name: prs.project.submittedBy.name,
|
||||
userId: prs.project.submittedBy.id,
|
||||
})
|
||||
if (prs.state === 'PASSED') advancedUserIds.add(prs.project.submittedBy.id)
|
||||
else rejectedUserIds.add(prs.project.submittedBy.id)
|
||||
} else if (recipients.length === 0 && prs.project.submittedByEmail) {
|
||||
recipients.push({ email: prs.project.submittedByEmail, name: null, userId: null })
|
||||
}
|
||||
|
||||
for (const recipient of recipients) {
|
||||
try {
|
||||
if (prs.state === 'PASSED') {
|
||||
// Build account creation URL for passwordless users
|
||||
const token = recipient.userId ? inviteTokenMap.get(recipient.userId) : undefined
|
||||
const accountUrl = token ? `/accept-invite?token=${token}` : undefined
|
||||
|
||||
await sendStyledNotificationEmail(
|
||||
recipient.email,
|
||||
recipient.name || '',
|
||||
'ADVANCEMENT_NOTIFICATION',
|
||||
{
|
||||
title: 'Your project has advanced!',
|
||||
message: '',
|
||||
linkUrl: accountUrl || '/applicant',
|
||||
metadata: {
|
||||
projectName: prs.project.title,
|
||||
fromRoundName: round.name,
|
||||
toRoundName: targetRoundName,
|
||||
customMessage: options.advancementMessage || undefined,
|
||||
accountUrl,
|
||||
},
|
||||
},
|
||||
)
|
||||
} else {
|
||||
await sendStyledNotificationEmail(
|
||||
recipient.email,
|
||||
recipient.name || '',
|
||||
'REJECTION_NOTIFICATION',
|
||||
{
|
||||
title: `Update on your application: "${prs.project.title}"`,
|
||||
message: '',
|
||||
metadata: {
|
||||
projectName: prs.project.title,
|
||||
roundName: round.name,
|
||||
customMessage: options.rejectionMessage || undefined,
|
||||
},
|
||||
},
|
||||
)
|
||||
}
|
||||
emailsSent++
|
||||
} catch (err) {
|
||||
console.error(`[Finalization] Email failed for ${recipient.email}:`, err)
|
||||
emailsFailed++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Create in-app notifications
|
||||
if (advancedUserIds.size > 0) {
|
||||
void createBulkNotifications({
|
||||
userIds: [...advancedUserIds],
|
||||
type: 'project_advanced',
|
||||
title: 'Your project has advanced!',
|
||||
message: `Your project has advanced from "${round.name}" to "${targetRoundName}".`,
|
||||
linkUrl: '/applicant',
|
||||
linkLabel: 'View Dashboard',
|
||||
icon: 'Trophy',
|
||||
priority: 'high',
|
||||
})
|
||||
}
|
||||
|
||||
if (rejectedUserIds.size > 0) {
|
||||
void createBulkNotifications({
|
||||
userIds: [...rejectedUserIds],
|
||||
type: 'project_rejected',
|
||||
title: 'Competition Update',
|
||||
message: `Your project did not advance past "${round.name}".`,
|
||||
linkUrl: '/applicant',
|
||||
linkLabel: 'View Dashboard',
|
||||
icon: 'Info',
|
||||
priority: 'normal',
|
||||
})
|
||||
}
|
||||
} catch (emailError) {
|
||||
console.error('[Finalization] Email batch failed (non-fatal):', emailError)
|
||||
}
|
||||
|
||||
// External audit log
|
||||
await logAudit({
|
||||
userId: actorId,
|
||||
action: 'ROUND_FINALIZED',
|
||||
entityType: 'Round',
|
||||
entityId: roundId,
|
||||
detailsJson: {
|
||||
roundName: round.name,
|
||||
advanced: result.advanced,
|
||||
rejected: result.rejected,
|
||||
emailsSent,
|
||||
emailsFailed,
|
||||
},
|
||||
})
|
||||
|
||||
return {
|
||||
advanced: result.advanced,
|
||||
rejected: result.rejected,
|
||||
emailsSent,
|
||||
emailsFailed,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user