1285 lines
44 KiB
TypeScript
1285 lines
44 KiB
TypeScript
import crypto from 'crypto'
|
|
import { z } from 'zod'
|
|
import { TRPCError } from '@trpc/server'
|
|
import { Prisma } from '@prisma/client'
|
|
import { router, protectedProcedure, adminProcedure } from '../trpc'
|
|
import { getUserAvatarUrl } from '../utils/avatar-url'
|
|
import {
|
|
notifyProjectTeam,
|
|
NotificationTypes,
|
|
} from '../services/in-app-notification'
|
|
import { normalizeCountryToCode } from '@/lib/countries'
|
|
import { logAudit } from '../utils/audit'
|
|
import { sendInvitationEmail } from '@/lib/email'
|
|
|
|
const INVITE_TOKEN_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000 // 7 days
|
|
|
|
// Valid project status transitions
|
|
const VALID_PROJECT_TRANSITIONS: Record<string, string[]> = {
|
|
SUBMITTED: ['ELIGIBLE', 'REJECTED'], // New submissions get screened
|
|
ELIGIBLE: ['ASSIGNED', 'REJECTED'], // Eligible projects get assigned to jurors
|
|
ASSIGNED: ['SEMIFINALIST', 'FINALIST', 'REJECTED'], // After evaluation
|
|
SEMIFINALIST: ['FINALIST', 'REJECTED'], // Semi-finalists advance or get cut
|
|
FINALIST: ['REJECTED'], // Finalists can only be rejected (rare)
|
|
REJECTED: ['SUBMITTED'], // Rejected can be re-submitted (admin override)
|
|
}
|
|
|
|
export const projectRouter = router({
|
|
/**
|
|
* List projects with filtering and pagination
|
|
* Admin sees all, jury sees only assigned projects
|
|
*/
|
|
list: protectedProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string().optional(),
|
|
roundId: z.string().optional(),
|
|
status: z
|
|
.enum([
|
|
'SUBMITTED',
|
|
'ELIGIBLE',
|
|
'ASSIGNED',
|
|
'SEMIFINALIST',
|
|
'FINALIST',
|
|
'REJECTED',
|
|
])
|
|
.optional(),
|
|
statuses: z.array(
|
|
z.enum([
|
|
'SUBMITTED',
|
|
'ELIGIBLE',
|
|
'ASSIGNED',
|
|
'SEMIFINALIST',
|
|
'FINALIST',
|
|
'REJECTED',
|
|
])
|
|
).optional(),
|
|
notInRoundId: z.string().optional(), // Exclude projects already in this round
|
|
unassignedOnly: z.boolean().optional(), // Projects not in any round
|
|
search: z.string().optional(),
|
|
tags: z.array(z.string()).optional(),
|
|
competitionCategory: z.enum(['STARTUP', 'BUSINESS_CONCEPT']).optional(),
|
|
oceanIssue: z.enum([
|
|
'POLLUTION_REDUCTION', 'CLIMATE_MITIGATION', 'TECHNOLOGY_INNOVATION',
|
|
'SUSTAINABLE_SHIPPING', 'BLUE_CARBON', 'HABITAT_RESTORATION',
|
|
'COMMUNITY_CAPACITY', 'SUSTAINABLE_FISHING', 'CONSUMER_AWARENESS',
|
|
'OCEAN_ACIDIFICATION', 'OTHER',
|
|
]).optional(),
|
|
country: z.string().optional(),
|
|
wantsMentorship: z.boolean().optional(),
|
|
hasFiles: z.boolean().optional(),
|
|
hasAssignments: z.boolean().optional(),
|
|
page: z.number().int().min(1).default(1),
|
|
perPage: z.number().int().min(1).max(200).default(20),
|
|
})
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const {
|
|
programId, roundId, notInRoundId, status, statuses, unassignedOnly, search, tags,
|
|
competitionCategory, oceanIssue, country,
|
|
wantsMentorship, hasFiles, hasAssignments,
|
|
page, perPage,
|
|
} = input
|
|
const skip = (page - 1) * perPage
|
|
|
|
// Build where clause
|
|
const where: Record<string, unknown> = {}
|
|
|
|
// Filter by program
|
|
if (programId) where.programId = programId
|
|
|
|
// Filter by round
|
|
if (roundId) {
|
|
where.roundId = roundId
|
|
}
|
|
|
|
// Exclude projects in a specific round (include unassigned projects with roundId=null)
|
|
if (notInRoundId) {
|
|
if (!where.AND) where.AND = []
|
|
;(where.AND as unknown[]).push({
|
|
OR: [
|
|
{ roundId: null },
|
|
{ roundId: { not: notInRoundId } },
|
|
],
|
|
})
|
|
}
|
|
|
|
// Filter by unassigned (no round)
|
|
if (unassignedOnly) {
|
|
where.roundId = null
|
|
}
|
|
|
|
// Status filter
|
|
if (statuses?.length || status) {
|
|
const statusValues = statuses?.length ? statuses : status ? [status] : []
|
|
if (statusValues.length > 0) {
|
|
where.status = { in: statusValues }
|
|
}
|
|
}
|
|
|
|
if (tags && tags.length > 0) {
|
|
where.tags = { hasSome: tags }
|
|
}
|
|
if (competitionCategory) where.competitionCategory = competitionCategory
|
|
if (oceanIssue) where.oceanIssue = oceanIssue
|
|
if (country) where.country = country
|
|
if (wantsMentorship !== undefined) where.wantsMentorship = wantsMentorship
|
|
if (hasFiles === true) where.files = { some: {} }
|
|
if (hasFiles === false) where.files = { none: {} }
|
|
if (hasAssignments === true) where.assignments = { some: {} }
|
|
if (hasAssignments === false) where.assignments = { none: {} }
|
|
|
|
if (search) {
|
|
where.OR = [
|
|
{ title: { contains: search, mode: 'insensitive' } },
|
|
{ teamName: { contains: search, mode: 'insensitive' } },
|
|
{ description: { contains: search, mode: 'insensitive' } },
|
|
]
|
|
}
|
|
|
|
// Jury members can only see assigned projects
|
|
if (ctx.user.role === 'JURY_MEMBER') {
|
|
where.assignments = {
|
|
...((where.assignments as Record<string, unknown>) || {}),
|
|
some: { userId: ctx.user.id },
|
|
}
|
|
}
|
|
|
|
const [projects, total] = await Promise.all([
|
|
ctx.prisma.project.findMany({
|
|
where,
|
|
skip,
|
|
take: perPage,
|
|
orderBy: { createdAt: 'desc' },
|
|
include: {
|
|
round: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
program: { select: { id: true, name: true, year: true } },
|
|
},
|
|
},
|
|
_count: { select: { assignments: true, files: true } },
|
|
},
|
|
}),
|
|
ctx.prisma.project.count({ where }),
|
|
])
|
|
|
|
return {
|
|
projects,
|
|
total,
|
|
page,
|
|
perPage,
|
|
totalPages: Math.ceil(total / perPage),
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* List all project IDs matching filters (no pagination).
|
|
* Used for "select all across pages" in bulk operations.
|
|
*/
|
|
listAllIds: adminProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string().optional(),
|
|
roundId: z.string().optional(),
|
|
notInRoundId: z.string().optional(),
|
|
unassignedOnly: z.boolean().optional(),
|
|
search: z.string().optional(),
|
|
statuses: z.array(
|
|
z.enum([
|
|
'SUBMITTED',
|
|
'ELIGIBLE',
|
|
'ASSIGNED',
|
|
'SEMIFINALIST',
|
|
'FINALIST',
|
|
'REJECTED',
|
|
])
|
|
).optional(),
|
|
tags: z.array(z.string()).optional(),
|
|
competitionCategory: z.enum(['STARTUP', 'BUSINESS_CONCEPT']).optional(),
|
|
oceanIssue: z.enum([
|
|
'POLLUTION_REDUCTION', 'CLIMATE_MITIGATION', 'TECHNOLOGY_INNOVATION',
|
|
'SUSTAINABLE_SHIPPING', 'BLUE_CARBON', 'HABITAT_RESTORATION',
|
|
'COMMUNITY_CAPACITY', 'SUSTAINABLE_FISHING', 'CONSUMER_AWARENESS',
|
|
'OCEAN_ACIDIFICATION', 'OTHER',
|
|
]).optional(),
|
|
country: z.string().optional(),
|
|
wantsMentorship: z.boolean().optional(),
|
|
hasFiles: z.boolean().optional(),
|
|
hasAssignments: z.boolean().optional(),
|
|
})
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const {
|
|
programId, roundId, notInRoundId, unassignedOnly,
|
|
search, statuses, tags,
|
|
competitionCategory, oceanIssue, country,
|
|
wantsMentorship, hasFiles, hasAssignments,
|
|
} = input
|
|
|
|
const where: Record<string, unknown> = {}
|
|
|
|
if (programId) where.programId = programId
|
|
if (roundId) where.roundId = roundId
|
|
if (notInRoundId) {
|
|
if (!where.AND) where.AND = []
|
|
;(where.AND as unknown[]).push({
|
|
OR: [
|
|
{ roundId: null },
|
|
{ roundId: { not: notInRoundId } },
|
|
],
|
|
})
|
|
}
|
|
if (unassignedOnly) where.roundId = null
|
|
if (statuses?.length) where.status = { in: statuses }
|
|
if (tags && tags.length > 0) where.tags = { hasSome: tags }
|
|
if (competitionCategory) where.competitionCategory = competitionCategory
|
|
if (oceanIssue) where.oceanIssue = oceanIssue
|
|
if (country) where.country = country
|
|
if (wantsMentorship !== undefined) where.wantsMentorship = wantsMentorship
|
|
if (hasFiles === true) where.files = { some: {} }
|
|
if (hasFiles === false) where.files = { none: {} }
|
|
if (hasAssignments === true) where.assignments = { some: {} }
|
|
if (hasAssignments === false) where.assignments = { none: {} }
|
|
if (search) {
|
|
where.OR = [
|
|
{ title: { contains: search, mode: 'insensitive' } },
|
|
{ teamName: { contains: search, mode: 'insensitive' } },
|
|
{ description: { contains: search, mode: 'insensitive' } },
|
|
]
|
|
}
|
|
|
|
const projects = await ctx.prisma.project.findMany({
|
|
where,
|
|
select: { id: true },
|
|
orderBy: { createdAt: 'desc' },
|
|
})
|
|
|
|
return { ids: projects.map((p) => p.id) }
|
|
}),
|
|
|
|
/**
|
|
* Get filter options for the project list (distinct values)
|
|
*/
|
|
getFilterOptions: protectedProcedure
|
|
.query(async ({ ctx }) => {
|
|
const [rounds, countries, categories, issues] = await Promise.all([
|
|
ctx.prisma.round.findMany({
|
|
select: { id: true, name: true, program: { select: { id: true, name: true, year: true } } },
|
|
orderBy: [{ program: { year: 'desc' } }, { createdAt: 'asc' }],
|
|
}),
|
|
ctx.prisma.project.findMany({
|
|
where: { country: { not: null } },
|
|
select: { country: true },
|
|
distinct: ['country'],
|
|
orderBy: { country: 'asc' },
|
|
}),
|
|
ctx.prisma.project.groupBy({
|
|
by: ['competitionCategory'],
|
|
where: { competitionCategory: { not: null } },
|
|
_count: true,
|
|
}),
|
|
ctx.prisma.project.groupBy({
|
|
by: ['oceanIssue'],
|
|
where: { oceanIssue: { not: null } },
|
|
_count: true,
|
|
}),
|
|
])
|
|
|
|
return {
|
|
rounds,
|
|
countries: countries.map((c) => c.country).filter(Boolean) as string[],
|
|
categories: categories.map((c) => ({
|
|
value: c.competitionCategory!,
|
|
count: c._count,
|
|
})),
|
|
issues: issues.map((i) => ({
|
|
value: i.oceanIssue!,
|
|
count: i._count,
|
|
})),
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Get a single project with details
|
|
*/
|
|
get: protectedProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const project = await ctx.prisma.project.findUniqueOrThrow({
|
|
where: { id: input.id },
|
|
include: {
|
|
files: true,
|
|
round: true,
|
|
teamMembers: {
|
|
include: {
|
|
user: {
|
|
select: { id: true, name: true, email: true, profileImageKey: true, profileImageProvider: true },
|
|
},
|
|
},
|
|
orderBy: { joinedAt: 'asc' },
|
|
},
|
|
mentorAssignment: {
|
|
include: {
|
|
mentor: {
|
|
select: { id: true, name: true, email: true, expertiseTags: true, profileImageKey: true, profileImageProvider: true },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
// Fetch project tags separately (table may not exist if migrations are pending)
|
|
let projectTags: { id: string; projectId: string; tagId: string; confidence: number; tag: { id: string; name: string; category: string | null; color: string | null } }[] = []
|
|
try {
|
|
projectTags = await ctx.prisma.projectTag.findMany({
|
|
where: { projectId: input.id },
|
|
include: { tag: { select: { id: true, name: true, category: true, color: true } } },
|
|
orderBy: { confidence: 'desc' },
|
|
})
|
|
} catch {
|
|
// ProjectTag table may not exist yet
|
|
}
|
|
|
|
// Check access for jury members
|
|
if (ctx.user.role === 'JURY_MEMBER') {
|
|
const assignment = await ctx.prisma.assignment.findFirst({
|
|
where: {
|
|
projectId: input.id,
|
|
userId: ctx.user.id,
|
|
},
|
|
})
|
|
|
|
if (!assignment) {
|
|
throw new TRPCError({
|
|
code: 'FORBIDDEN',
|
|
message: 'You are not assigned to this project',
|
|
})
|
|
}
|
|
}
|
|
|
|
// Attach avatar URLs to team members and mentor
|
|
const teamMembersWithAvatars = await Promise.all(
|
|
project.teamMembers.map(async (member) => ({
|
|
...member,
|
|
user: {
|
|
...member.user,
|
|
avatarUrl: await getUserAvatarUrl(member.user.profileImageKey, member.user.profileImageProvider),
|
|
},
|
|
}))
|
|
)
|
|
|
|
const mentorWithAvatar = project.mentorAssignment
|
|
? {
|
|
...project.mentorAssignment,
|
|
mentor: {
|
|
...project.mentorAssignment.mentor,
|
|
avatarUrl: await getUserAvatarUrl(
|
|
project.mentorAssignment.mentor.profileImageKey,
|
|
project.mentorAssignment.mentor.profileImageProvider
|
|
),
|
|
},
|
|
}
|
|
: null
|
|
|
|
return {
|
|
...project,
|
|
projectTags,
|
|
teamMembers: teamMembersWithAvatars,
|
|
mentorAssignment: mentorWithAvatar,
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Create a single project (admin only)
|
|
* Projects belong to a round.
|
|
*/
|
|
create: adminProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string(),
|
|
roundId: z.string().optional(),
|
|
title: z.string().min(1).max(500),
|
|
teamName: z.string().optional(),
|
|
description: z.string().optional(),
|
|
tags: z.array(z.string()).optional(),
|
|
country: z.string().optional(),
|
|
competitionCategory: z.enum(['STARTUP', 'BUSINESS_CONCEPT']).optional(),
|
|
oceanIssue: z.enum([
|
|
'POLLUTION_REDUCTION', 'CLIMATE_MITIGATION', 'TECHNOLOGY_INNOVATION',
|
|
'SUSTAINABLE_SHIPPING', 'BLUE_CARBON', 'HABITAT_RESTORATION',
|
|
'COMMUNITY_CAPACITY', 'SUSTAINABLE_FISHING', 'CONSUMER_AWARENESS',
|
|
'OCEAN_ACIDIFICATION', 'OTHER',
|
|
]).optional(),
|
|
institution: z.string().optional(),
|
|
contactPhone: z.string().optional(),
|
|
contactEmail: z.string().email('Invalid email address').optional(),
|
|
contactName: z.string().optional(),
|
|
city: z.string().optional(),
|
|
metadataJson: z.record(z.unknown()).optional(),
|
|
teamMembers: z.array(z.object({
|
|
name: z.string().min(1),
|
|
email: z.string().email(),
|
|
role: z.enum(['LEAD', 'MEMBER', 'ADVISOR']),
|
|
title: z.string().optional(),
|
|
phone: z.string().optional(),
|
|
sendInvite: z.boolean().default(false),
|
|
})).max(10).optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const {
|
|
metadataJson,
|
|
contactPhone, contactEmail, contactName, city,
|
|
teamMembers: teamMembersInput,
|
|
...rest
|
|
} = input
|
|
|
|
// If roundId provided, derive programId from round for validation
|
|
let resolvedProgramId = input.programId
|
|
if (input.roundId) {
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
select: { programId: true },
|
|
})
|
|
resolvedProgramId = round.programId
|
|
}
|
|
|
|
// Build metadata from contact fields + any additional metadata
|
|
const fullMetadata: Record<string, unknown> = { ...metadataJson }
|
|
if (contactPhone) fullMetadata.contactPhone = contactPhone
|
|
if (contactEmail) fullMetadata.contactEmail = contactEmail
|
|
if (contactName) fullMetadata.contactName = contactName
|
|
if (city) fullMetadata.city = city
|
|
|
|
// Normalize country to ISO code if provided
|
|
const normalizedCountry = input.country
|
|
? normalizeCountryToCode(input.country)
|
|
: undefined
|
|
|
|
const { project, membersToInvite } = await ctx.prisma.$transaction(async (tx) => {
|
|
const created = await tx.project.create({
|
|
data: {
|
|
programId: resolvedProgramId,
|
|
roundId: input.roundId || null,
|
|
title: input.title,
|
|
teamName: input.teamName,
|
|
description: input.description,
|
|
tags: input.tags || [],
|
|
country: normalizedCountry,
|
|
competitionCategory: input.competitionCategory,
|
|
oceanIssue: input.oceanIssue,
|
|
institution: input.institution,
|
|
metadataJson: Object.keys(fullMetadata).length > 0
|
|
? (fullMetadata as Prisma.InputJsonValue)
|
|
: undefined,
|
|
status: 'SUBMITTED',
|
|
},
|
|
})
|
|
|
|
// Create team members if provided
|
|
const inviteList: { userId: string; email: string; name: string }[] = []
|
|
if (teamMembersInput && teamMembersInput.length > 0) {
|
|
for (const member of teamMembersInput) {
|
|
// Find or create user
|
|
let user = await tx.user.findUnique({
|
|
where: { email: member.email.toLowerCase() },
|
|
select: { id: true, status: true },
|
|
})
|
|
|
|
if (!user) {
|
|
user = await tx.user.create({
|
|
data: {
|
|
email: member.email.toLowerCase(),
|
|
name: member.name,
|
|
role: 'APPLICANT',
|
|
status: 'NONE',
|
|
phoneNumber: member.phone || null,
|
|
},
|
|
select: { id: true, status: true },
|
|
})
|
|
}
|
|
|
|
// Create TeamMember link (skip if already linked)
|
|
await tx.teamMember.upsert({
|
|
where: {
|
|
projectId_userId: {
|
|
projectId: created.id,
|
|
userId: user.id,
|
|
},
|
|
},
|
|
create: {
|
|
projectId: created.id,
|
|
userId: user.id,
|
|
role: member.role,
|
|
title: member.title || null,
|
|
},
|
|
update: {
|
|
role: member.role,
|
|
title: member.title || null,
|
|
},
|
|
})
|
|
|
|
if (member.sendInvite) {
|
|
inviteList.push({ userId: user.id, email: member.email.toLowerCase(), name: member.name })
|
|
}
|
|
}
|
|
}
|
|
|
|
await logAudit({
|
|
prisma: tx,
|
|
userId: ctx.user.id,
|
|
action: 'CREATE',
|
|
entityType: 'Project',
|
|
entityId: created.id,
|
|
detailsJson: {
|
|
title: input.title,
|
|
roundId: input.roundId,
|
|
programId: resolvedProgramId,
|
|
teamMembersCount: teamMembersInput?.length || 0,
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return { project: created, membersToInvite: inviteList }
|
|
})
|
|
|
|
// Send invite emails outside the transaction (never fail project creation)
|
|
if (membersToInvite.length > 0) {
|
|
const baseUrl = process.env.NEXTAUTH_URL || 'https://monaco-opc.com'
|
|
for (const member of membersToInvite) {
|
|
try {
|
|
const token = crypto.randomBytes(32).toString('hex')
|
|
await ctx.prisma.user.update({
|
|
where: { id: member.userId },
|
|
data: {
|
|
status: 'INVITED',
|
|
inviteToken: token,
|
|
inviteTokenExpiresAt: new Date(Date.now() + INVITE_TOKEN_EXPIRY_MS),
|
|
},
|
|
})
|
|
|
|
const inviteUrl = `${baseUrl}/accept-invite?token=${token}`
|
|
await sendInvitationEmail(member.email, member.name, inviteUrl, 'APPLICANT')
|
|
|
|
// Log notification
|
|
try {
|
|
await ctx.prisma.notificationLog.create({
|
|
data: {
|
|
userId: member.userId,
|
|
channel: 'EMAIL',
|
|
type: 'JURY_INVITATION',
|
|
status: 'SENT',
|
|
},
|
|
})
|
|
} catch {
|
|
// Never fail on notification logging
|
|
}
|
|
} catch {
|
|
// Email sending failure should not break project creation
|
|
console.error(`Failed to send invite to ${member.email}`)
|
|
}
|
|
}
|
|
}
|
|
|
|
return project
|
|
}),
|
|
|
|
/**
|
|
* Update a project (admin only)
|
|
* Status updates require a roundId context since status is per-round.
|
|
*/
|
|
update: adminProcedure
|
|
.input(
|
|
z.object({
|
|
id: z.string(),
|
|
title: z.string().min(1).max(500).optional(),
|
|
teamName: z.string().optional().nullable(),
|
|
description: z.string().optional().nullable(),
|
|
country: z.string().optional().nullable(), // ISO-2 code or country name (will be normalized)
|
|
// Status update requires roundId
|
|
roundId: z.string().optional(),
|
|
status: z
|
|
.enum([
|
|
'SUBMITTED',
|
|
'ELIGIBLE',
|
|
'ASSIGNED',
|
|
'SEMIFINALIST',
|
|
'FINALIST',
|
|
'REJECTED',
|
|
])
|
|
.optional(),
|
|
tags: z.array(z.string()).optional(),
|
|
metadataJson: z.record(z.unknown()).optional(),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const { id, metadataJson, status, roundId, country, ...data } = input
|
|
|
|
// Normalize country to ISO-2 code if provided
|
|
const normalizedCountry = country !== undefined
|
|
? (country === null ? null : normalizeCountryToCode(country))
|
|
: undefined
|
|
|
|
// Validate status transition if status is being changed
|
|
if (status) {
|
|
const currentProject = await ctx.prisma.project.findUniqueOrThrow({
|
|
where: { id },
|
|
select: { status: true },
|
|
})
|
|
const allowedTransitions = VALID_PROJECT_TRANSITIONS[currentProject.status] || []
|
|
if (!allowedTransitions.includes(status)) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: `Invalid status transition: cannot change from ${currentProject.status} to ${status}. Allowed: ${allowedTransitions.join(', ') || 'none'}`,
|
|
})
|
|
}
|
|
}
|
|
|
|
const project = await ctx.prisma.$transaction(async (tx) => {
|
|
const updated = await tx.project.update({
|
|
where: { id },
|
|
data: {
|
|
...data,
|
|
...(status && { status }),
|
|
...(normalizedCountry !== undefined && { country: normalizedCountry }),
|
|
metadataJson: metadataJson as Prisma.InputJsonValue ?? undefined,
|
|
},
|
|
})
|
|
|
|
// Record status change in history
|
|
if (status) {
|
|
await tx.projectStatusHistory.create({
|
|
data: {
|
|
projectId: id,
|
|
status,
|
|
changedBy: ctx.user.id,
|
|
},
|
|
})
|
|
}
|
|
|
|
return updated
|
|
})
|
|
|
|
// Send notifications if status changed
|
|
if (status) {
|
|
// Get round details for notification
|
|
const projectWithRound = await ctx.prisma.project.findUnique({
|
|
where: { id },
|
|
include: { round: { select: { name: true, entryNotificationType: true, program: { select: { name: true } } } } },
|
|
})
|
|
|
|
const round = projectWithRound?.round
|
|
|
|
// Helper to get notification title based on type
|
|
const getNotificationTitle = (type: string): string => {
|
|
const titles: Record<string, string> = {
|
|
ADVANCED_SEMIFINAL: "Congratulations! You're a Semi-Finalist",
|
|
ADVANCED_FINAL: "Amazing News! You're a Finalist",
|
|
NOT_SELECTED: 'Application Status Update',
|
|
WINNER_ANNOUNCEMENT: 'Congratulations! You Won!',
|
|
}
|
|
return titles[type] || 'Project Update'
|
|
}
|
|
|
|
// Helper to get notification message based on type
|
|
const getNotificationMessage = (type: string, projectName: string): string => {
|
|
const messages: Record<string, (name: string) => string> = {
|
|
ADVANCED_SEMIFINAL: (name) => `Your project "${name}" has advanced to the semi-finals!`,
|
|
ADVANCED_FINAL: (name) => `Your project "${name}" has been selected as a finalist!`,
|
|
NOT_SELECTED: (name) => `We regret to inform you that "${name}" was not selected for the next round.`,
|
|
WINNER_ANNOUNCEMENT: (name) => `Your project "${name}" has been selected as a winner!`,
|
|
}
|
|
return messages[type]?.(projectName) || `Update regarding your project "${projectName}".`
|
|
}
|
|
|
|
// Use round's configured notification type, or fall back to status-based defaults
|
|
if (round?.entryNotificationType) {
|
|
await notifyProjectTeam(id, {
|
|
type: round.entryNotificationType,
|
|
title: getNotificationTitle(round.entryNotificationType),
|
|
message: getNotificationMessage(round.entryNotificationType, project.title),
|
|
linkUrl: `/team/projects/${id}`,
|
|
linkLabel: 'View Project',
|
|
priority: round.entryNotificationType === 'NOT_SELECTED' ? 'normal' : 'high',
|
|
metadata: {
|
|
projectName: project.title,
|
|
roundName: round.name,
|
|
programName: round.program?.name,
|
|
},
|
|
})
|
|
} else if (round) {
|
|
// Fall back to hardcoded status-based notifications
|
|
const notificationConfig: Record<
|
|
string,
|
|
{ type: string; title: string; message: string }
|
|
> = {
|
|
SEMIFINALIST: {
|
|
type: NotificationTypes.ADVANCED_SEMIFINAL,
|
|
title: "Congratulations! You're a Semi-Finalist",
|
|
message: `Your project "${project.title}" has advanced to the semi-finals!`,
|
|
},
|
|
FINALIST: {
|
|
type: NotificationTypes.ADVANCED_FINAL,
|
|
title: "Amazing News! You're a Finalist",
|
|
message: `Your project "${project.title}" has been selected as a finalist!`,
|
|
},
|
|
REJECTED: {
|
|
type: NotificationTypes.NOT_SELECTED,
|
|
title: 'Application Status Update',
|
|
message: `We regret to inform you that "${project.title}" was not selected for the next round.`,
|
|
},
|
|
}
|
|
|
|
const config = notificationConfig[status]
|
|
if (config) {
|
|
await notifyProjectTeam(id, {
|
|
type: config.type,
|
|
title: config.title,
|
|
message: config.message,
|
|
linkUrl: `/team/projects/${id}`,
|
|
linkLabel: 'View Project',
|
|
priority: status === 'REJECTED' ? 'normal' : 'high',
|
|
metadata: {
|
|
projectName: project.title,
|
|
roundName: round?.name,
|
|
programName: round?.program?.name,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Audit log
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'UPDATE',
|
|
entityType: 'Project',
|
|
entityId: id,
|
|
detailsJson: { ...data, status, metadataJson } as Record<string, unknown>,
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return project
|
|
}),
|
|
|
|
/**
|
|
* Delete a project (admin only)
|
|
*/
|
|
delete: adminProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const project = await ctx.prisma.$transaction(async (tx) => {
|
|
const target = await tx.project.findUniqueOrThrow({
|
|
where: { id: input.id },
|
|
select: { id: true, title: true },
|
|
})
|
|
|
|
await logAudit({
|
|
prisma: tx,
|
|
userId: ctx.user.id,
|
|
action: 'DELETE',
|
|
entityType: 'Project',
|
|
entityId: input.id,
|
|
detailsJson: { title: target.title },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return tx.project.delete({
|
|
where: { id: input.id },
|
|
})
|
|
})
|
|
|
|
return project
|
|
}),
|
|
|
|
/**
|
|
* Bulk delete projects (admin only)
|
|
*/
|
|
bulkDelete: adminProcedure
|
|
.input(
|
|
z.object({
|
|
ids: z.array(z.string()).min(1).max(200),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
const projects = await ctx.prisma.project.findMany({
|
|
where: { id: { in: input.ids } },
|
|
select: { id: true, title: true },
|
|
})
|
|
|
|
if (projects.length === 0) {
|
|
throw new TRPCError({
|
|
code: 'NOT_FOUND',
|
|
message: 'No projects found to delete',
|
|
})
|
|
}
|
|
|
|
const result = await ctx.prisma.$transaction(async (tx) => {
|
|
await logAudit({
|
|
prisma: tx,
|
|
userId: ctx.user.id,
|
|
action: 'BULK_DELETE',
|
|
entityType: 'Project',
|
|
detailsJson: {
|
|
count: projects.length,
|
|
titles: projects.map((p) => p.title),
|
|
ids: projects.map((p) => p.id),
|
|
},
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return tx.project.deleteMany({
|
|
where: { id: { in: projects.map((p) => p.id) } },
|
|
})
|
|
})
|
|
|
|
return { deleted: result.count }
|
|
}),
|
|
|
|
/**
|
|
* Import projects from CSV data (admin only)
|
|
* Projects belong to a program. Optionally assign to a round.
|
|
*/
|
|
importCSV: adminProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string(),
|
|
roundId: z.string().optional(),
|
|
projects: z.array(
|
|
z.object({
|
|
title: z.string().min(1),
|
|
teamName: z.string().optional(),
|
|
description: z.string().optional(),
|
|
tags: z.array(z.string()).optional(),
|
|
metadataJson: z.record(z.unknown()).optional(),
|
|
})
|
|
),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
// Verify program exists
|
|
await ctx.prisma.program.findUniqueOrThrow({
|
|
where: { id: input.programId },
|
|
})
|
|
|
|
// Verify round exists and belongs to program if provided
|
|
if (input.roundId) {
|
|
const round = await ctx.prisma.round.findUniqueOrThrow({
|
|
where: { id: input.roundId },
|
|
})
|
|
if (round.programId !== input.programId) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: 'Round does not belong to the selected program',
|
|
})
|
|
}
|
|
}
|
|
|
|
// Create projects in a transaction
|
|
const result = await ctx.prisma.$transaction(async (tx) => {
|
|
// Create all projects with roundId and programId
|
|
const projectData = input.projects.map((p) => {
|
|
const { metadataJson, ...rest } = p
|
|
return {
|
|
...rest,
|
|
programId: input.programId,
|
|
roundId: input.roundId!,
|
|
status: 'SUBMITTED' as const,
|
|
metadataJson: metadataJson as Prisma.InputJsonValue ?? undefined,
|
|
}
|
|
})
|
|
|
|
const created = await tx.project.createManyAndReturn({
|
|
data: projectData,
|
|
select: { id: true },
|
|
})
|
|
|
|
return { imported: created.length }
|
|
})
|
|
|
|
// Audit log
|
|
await logAudit({
|
|
prisma: ctx.prisma,
|
|
userId: ctx.user.id,
|
|
action: 'IMPORT',
|
|
entityType: 'Project',
|
|
detailsJson: { programId: input.programId, roundId: input.roundId, count: result.imported },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return result
|
|
}),
|
|
|
|
/**
|
|
* Get all unique tags used in projects
|
|
*/
|
|
getTags: protectedProcedure
|
|
.input(z.object({
|
|
roundId: z.string().optional(),
|
|
programId: z.string().optional(),
|
|
}))
|
|
.query(async ({ ctx, input }) => {
|
|
const where: Record<string, unknown> = {}
|
|
if (input.programId) where.round = { programId: input.programId }
|
|
if (input.roundId) where.roundId = input.roundId
|
|
|
|
const projects = await ctx.prisma.project.findMany({
|
|
where: Object.keys(where).length > 0 ? where : undefined,
|
|
select: { tags: true },
|
|
})
|
|
|
|
const allTags = projects.flatMap((p) => p.tags)
|
|
const uniqueTags = [...new Set(allTags)].sort()
|
|
|
|
return uniqueTags
|
|
}),
|
|
|
|
/**
|
|
* Update project status in bulk (admin only)
|
|
* Status is per-round, so roundId is required.
|
|
*/
|
|
bulkUpdateStatus: adminProcedure
|
|
.input(
|
|
z.object({
|
|
ids: z.array(z.string()),
|
|
roundId: z.string(),
|
|
status: z.enum([
|
|
'SUBMITTED',
|
|
'ELIGIBLE',
|
|
'ASSIGNED',
|
|
'SEMIFINALIST',
|
|
'FINALIST',
|
|
'REJECTED',
|
|
]),
|
|
})
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
// Fetch matching projects BEFORE update so notifications match actually-updated records
|
|
const [projects, round] = await Promise.all([
|
|
ctx.prisma.project.findMany({
|
|
where: {
|
|
id: { in: input.ids },
|
|
roundId: input.roundId,
|
|
},
|
|
select: { id: true, title: true },
|
|
}),
|
|
ctx.prisma.round.findUnique({
|
|
where: { id: input.roundId },
|
|
select: { name: true, entryNotificationType: true, program: { select: { name: true } } },
|
|
}),
|
|
])
|
|
|
|
const matchingIds = projects.map((p) => p.id)
|
|
|
|
// Validate status transitions for all projects
|
|
const projectsWithStatus = await ctx.prisma.project.findMany({
|
|
where: { id: { in: matchingIds }, roundId: input.roundId },
|
|
select: { id: true, title: true, status: true },
|
|
})
|
|
const invalidTransitions: string[] = []
|
|
for (const p of projectsWithStatus) {
|
|
const allowed = VALID_PROJECT_TRANSITIONS[p.status] || []
|
|
if (!allowed.includes(input.status)) {
|
|
invalidTransitions.push(`"${p.title}" (${p.status} → ${input.status})`)
|
|
}
|
|
}
|
|
if (invalidTransitions.length > 0) {
|
|
throw new TRPCError({
|
|
code: 'BAD_REQUEST',
|
|
message: `Invalid transitions for ${invalidTransitions.length} project(s): ${invalidTransitions.slice(0, 3).join('; ')}${invalidTransitions.length > 3 ? ` and ${invalidTransitions.length - 3} more` : ''}`,
|
|
})
|
|
}
|
|
|
|
const updated = await ctx.prisma.$transaction(async (tx) => {
|
|
const result = await tx.project.updateMany({
|
|
where: { id: { in: matchingIds }, roundId: input.roundId },
|
|
data: { status: input.status },
|
|
})
|
|
|
|
if (matchingIds.length > 0) {
|
|
await tx.projectStatusHistory.createMany({
|
|
data: matchingIds.map((projectId) => ({
|
|
projectId,
|
|
status: input.status,
|
|
changedBy: ctx.user.id,
|
|
})),
|
|
})
|
|
}
|
|
|
|
await logAudit({
|
|
prisma: tx,
|
|
userId: ctx.user.id,
|
|
action: 'BULK_UPDATE_STATUS',
|
|
entityType: 'Project',
|
|
detailsJson: { ids: matchingIds, roundId: input.roundId, status: input.status, count: result.count },
|
|
ipAddress: ctx.ip,
|
|
userAgent: ctx.userAgent,
|
|
})
|
|
|
|
return result
|
|
})
|
|
|
|
// Helper to get notification title based on type
|
|
const getNotificationTitle = (type: string): string => {
|
|
const titles: Record<string, string> = {
|
|
ADVANCED_SEMIFINAL: "Congratulations! You're a Semi-Finalist",
|
|
ADVANCED_FINAL: "Amazing News! You're a Finalist",
|
|
NOT_SELECTED: 'Application Status Update',
|
|
WINNER_ANNOUNCEMENT: 'Congratulations! You Won!',
|
|
}
|
|
return titles[type] || 'Project Update'
|
|
}
|
|
|
|
// Helper to get notification message based on type
|
|
const getNotificationMessage = (type: string, projectName: string): string => {
|
|
const messages: Record<string, (name: string) => string> = {
|
|
ADVANCED_SEMIFINAL: (name) => `Your project "${name}" has advanced to the semi-finals!`,
|
|
ADVANCED_FINAL: (name) => `Your project "${name}" has been selected as a finalist!`,
|
|
NOT_SELECTED: (name) => `We regret to inform you that "${name}" was not selected for the next round.`,
|
|
WINNER_ANNOUNCEMENT: (name) => `Your project "${name}" has been selected as a winner!`,
|
|
}
|
|
return messages[type]?.(projectName) || `Update regarding your project "${projectName}".`
|
|
}
|
|
|
|
// Notify project teams based on round's configured notification or status-based fallback
|
|
if (projects.length > 0) {
|
|
if (round?.entryNotificationType) {
|
|
// Use round's configured notification type
|
|
for (const project of projects) {
|
|
await notifyProjectTeam(project.id, {
|
|
type: round.entryNotificationType,
|
|
title: getNotificationTitle(round.entryNotificationType),
|
|
message: getNotificationMessage(round.entryNotificationType, project.title),
|
|
linkUrl: `/team/projects/${project.id}`,
|
|
linkLabel: 'View Project',
|
|
priority: round.entryNotificationType === 'NOT_SELECTED' ? 'normal' : 'high',
|
|
metadata: {
|
|
projectName: project.title,
|
|
roundName: round.name,
|
|
programName: round.program?.name,
|
|
},
|
|
})
|
|
}
|
|
} else {
|
|
// Fall back to hardcoded status-based notifications
|
|
const notificationConfig: Record<
|
|
string,
|
|
{ type: string; titleFn: (name: string) => string; messageFn: (name: string) => string }
|
|
> = {
|
|
SEMIFINALIST: {
|
|
type: NotificationTypes.ADVANCED_SEMIFINAL,
|
|
titleFn: () => "Congratulations! You're a Semi-Finalist",
|
|
messageFn: (name) => `Your project "${name}" has advanced to the semi-finals!`,
|
|
},
|
|
FINALIST: {
|
|
type: NotificationTypes.ADVANCED_FINAL,
|
|
titleFn: () => "Amazing News! You're a Finalist",
|
|
messageFn: (name) => `Your project "${name}" has been selected as a finalist!`,
|
|
},
|
|
REJECTED: {
|
|
type: NotificationTypes.NOT_SELECTED,
|
|
titleFn: () => 'Application Status Update',
|
|
messageFn: (name) =>
|
|
`We regret to inform you that "${name}" was not selected for the next round.`,
|
|
},
|
|
}
|
|
|
|
const config = notificationConfig[input.status]
|
|
if (config) {
|
|
for (const project of projects) {
|
|
await notifyProjectTeam(project.id, {
|
|
type: config.type,
|
|
title: config.titleFn(project.title),
|
|
message: config.messageFn(project.title),
|
|
linkUrl: `/team/projects/${project.id}`,
|
|
linkLabel: 'View Project',
|
|
priority: input.status === 'REJECTED' ? 'normal' : 'high',
|
|
metadata: {
|
|
projectName: project.title,
|
|
roundName: round?.name,
|
|
programName: round?.program?.name,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return { updated: updated.count }
|
|
}),
|
|
|
|
/**
|
|
* List projects in a program's pool (not assigned to any round)
|
|
*/
|
|
listPool: adminProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string(),
|
|
search: z.string().optional(),
|
|
page: z.number().int().min(1).default(1),
|
|
perPage: z.number().int().min(1).max(100).default(50),
|
|
})
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const { programId, search, page, perPage } = input
|
|
const skip = (page - 1) * perPage
|
|
|
|
const where: Record<string, unknown> = {
|
|
programId,
|
|
roundId: null,
|
|
}
|
|
|
|
if (search) {
|
|
where.OR = [
|
|
{ title: { contains: search, mode: 'insensitive' } },
|
|
{ teamName: { contains: search, mode: 'insensitive' } },
|
|
]
|
|
}
|
|
|
|
const [projects, total] = await Promise.all([
|
|
ctx.prisma.project.findMany({
|
|
where,
|
|
skip,
|
|
take: perPage,
|
|
orderBy: { createdAt: 'desc' },
|
|
select: {
|
|
id: true,
|
|
title: true,
|
|
teamName: true,
|
|
country: true,
|
|
competitionCategory: true,
|
|
createdAt: true,
|
|
},
|
|
}),
|
|
ctx.prisma.project.count({ where }),
|
|
])
|
|
|
|
return { projects, total, page, perPage, totalPages: Math.ceil(total / perPage) }
|
|
}),
|
|
|
|
/**
|
|
* Get full project detail with assignments and evaluation stats in one call.
|
|
* Reduces client-side waterfall by combining project.get + assignment.listByProject + evaluation.getProjectStats.
|
|
*/
|
|
getFullDetail: adminProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const [projectRaw, projectTags, assignments, submittedEvaluations] = await Promise.all([
|
|
ctx.prisma.project.findUniqueOrThrow({
|
|
where: { id: input.id },
|
|
include: {
|
|
files: true,
|
|
round: true,
|
|
teamMembers: {
|
|
include: {
|
|
user: {
|
|
select: { id: true, name: true, email: true, profileImageKey: true, profileImageProvider: true },
|
|
},
|
|
},
|
|
orderBy: { joinedAt: 'asc' },
|
|
},
|
|
mentorAssignment: {
|
|
include: {
|
|
mentor: {
|
|
select: { id: true, name: true, email: true, expertiseTags: true, profileImageKey: true, profileImageProvider: true },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
ctx.prisma.projectTag.findMany({
|
|
where: { projectId: input.id },
|
|
include: { tag: { select: { id: true, name: true, category: true, color: true } } },
|
|
orderBy: { confidence: 'desc' },
|
|
}).catch(() => [] as { id: string; projectId: string; tagId: string; confidence: number; tag: { id: string; name: string; category: string | null; color: string | null } }[]),
|
|
ctx.prisma.assignment.findMany({
|
|
where: { projectId: input.id },
|
|
include: {
|
|
user: { select: { id: true, name: true, email: true, expertiseTags: true, profileImageKey: true, profileImageProvider: true } },
|
|
evaluation: { select: { status: true, submittedAt: true, globalScore: true, binaryDecision: true } },
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
}),
|
|
ctx.prisma.evaluation.findMany({
|
|
where: {
|
|
status: 'SUBMITTED',
|
|
assignment: { projectId: input.id },
|
|
},
|
|
}),
|
|
])
|
|
|
|
// Compute evaluation stats
|
|
let stats = null
|
|
if (submittedEvaluations.length > 0) {
|
|
const globalScores = submittedEvaluations
|
|
.map((e) => e.globalScore)
|
|
.filter((s): s is number => s !== null)
|
|
const yesVotes = submittedEvaluations.filter((e) => e.binaryDecision === true).length
|
|
stats = {
|
|
totalEvaluations: submittedEvaluations.length,
|
|
averageGlobalScore: globalScores.length > 0
|
|
? globalScores.reduce((a, b) => a + b, 0) / globalScores.length
|
|
: null,
|
|
minScore: globalScores.length > 0 ? Math.min(...globalScores) : null,
|
|
maxScore: globalScores.length > 0 ? Math.max(...globalScores) : null,
|
|
yesVotes,
|
|
noVotes: submittedEvaluations.length - yesVotes,
|
|
yesPercentage: (yesVotes / submittedEvaluations.length) * 100,
|
|
}
|
|
}
|
|
|
|
// Attach avatar URLs in parallel
|
|
const [teamMembersWithAvatars, assignmentsWithAvatars, mentorWithAvatar] = await Promise.all([
|
|
Promise.all(
|
|
projectRaw.teamMembers.map(async (member) => ({
|
|
...member,
|
|
user: {
|
|
...member.user,
|
|
avatarUrl: await getUserAvatarUrl(member.user.profileImageKey, member.user.profileImageProvider),
|
|
},
|
|
}))
|
|
),
|
|
Promise.all(
|
|
assignments.map(async (a) => ({
|
|
...a,
|
|
user: {
|
|
...a.user,
|
|
avatarUrl: await getUserAvatarUrl(a.user.profileImageKey, a.user.profileImageProvider),
|
|
},
|
|
}))
|
|
),
|
|
projectRaw.mentorAssignment
|
|
? (async () => ({
|
|
...projectRaw.mentorAssignment!,
|
|
mentor: {
|
|
...projectRaw.mentorAssignment!.mentor,
|
|
avatarUrl: await getUserAvatarUrl(
|
|
projectRaw.mentorAssignment!.mentor.profileImageKey,
|
|
projectRaw.mentorAssignment!.mentor.profileImageProvider
|
|
),
|
|
},
|
|
}))()
|
|
: Promise.resolve(null),
|
|
])
|
|
|
|
return {
|
|
project: {
|
|
...projectRaw,
|
|
projectTags,
|
|
teamMembers: teamMembersWithAvatars,
|
|
mentorAssignment: mentorWithAvatar,
|
|
},
|
|
assignments: assignmentsWithAvatars,
|
|
stats,
|
|
}
|
|
}),
|
|
})
|