371 lines
10 KiB
TypeScript
371 lines
10 KiB
TypeScript
import { z } from 'zod'
|
|
import { router, protectedProcedure, adminProcedure } from '../trpc'
|
|
|
|
export const analyticsRouter = router({
|
|
/**
|
|
* Get score distribution for a round (histogram data)
|
|
*/
|
|
getScoreDistribution: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const evaluations = await ctx.prisma.evaluation.findMany({
|
|
where: {
|
|
assignment: { roundId: input.roundId },
|
|
status: 'SUBMITTED',
|
|
},
|
|
select: {
|
|
criterionScoresJson: true,
|
|
},
|
|
})
|
|
|
|
// Extract all scores and calculate distribution
|
|
const allScores: number[] = []
|
|
evaluations.forEach((evaluation) => {
|
|
const scores = evaluation.criterionScoresJson as Record<string, number> | null
|
|
if (scores) {
|
|
Object.values(scores).forEach((score) => {
|
|
if (typeof score === 'number') {
|
|
allScores.push(score)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
// Count scores by bucket (1-10)
|
|
const distribution = Array.from({ length: 10 }, (_, i) => ({
|
|
score: i + 1,
|
|
count: allScores.filter((s) => Math.round(s) === i + 1).length,
|
|
}))
|
|
|
|
return {
|
|
distribution,
|
|
totalScores: allScores.length,
|
|
averageScore:
|
|
allScores.length > 0
|
|
? allScores.reduce((a, b) => a + b, 0) / allScores.length
|
|
: 0,
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Get evaluation completion over time (timeline data)
|
|
*/
|
|
getEvaluationTimeline: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const evaluations = await ctx.prisma.evaluation.findMany({
|
|
where: {
|
|
assignment: { roundId: input.roundId },
|
|
status: 'SUBMITTED',
|
|
},
|
|
select: {
|
|
submittedAt: true,
|
|
},
|
|
orderBy: { submittedAt: 'asc' },
|
|
})
|
|
|
|
// Group by date
|
|
const byDate: Record<string, number> = {}
|
|
let cumulative = 0
|
|
|
|
evaluations.forEach((evaluation) => {
|
|
if (evaluation.submittedAt) {
|
|
const date = evaluation.submittedAt.toISOString().split('T')[0]
|
|
if (!byDate[date]) {
|
|
byDate[date] = 0
|
|
}
|
|
byDate[date]++
|
|
}
|
|
})
|
|
|
|
// Convert to cumulative timeline
|
|
const timeline = Object.entries(byDate)
|
|
.sort(([a], [b]) => a.localeCompare(b))
|
|
.map(([date, count]) => {
|
|
cumulative += count
|
|
return {
|
|
date,
|
|
daily: count,
|
|
cumulative,
|
|
}
|
|
})
|
|
|
|
return timeline
|
|
}),
|
|
|
|
/**
|
|
* Get juror workload distribution
|
|
*/
|
|
getJurorWorkload: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const assignments = await ctx.prisma.assignment.findMany({
|
|
where: { roundId: input.roundId },
|
|
include: {
|
|
user: { select: { name: true, email: true } },
|
|
evaluation: {
|
|
select: { id: true, status: true },
|
|
},
|
|
},
|
|
})
|
|
|
|
// Group by user
|
|
const byUser: Record<
|
|
string,
|
|
{ name: string; assigned: number; completed: number }
|
|
> = {}
|
|
|
|
assignments.forEach((assignment) => {
|
|
const userId = assignment.userId
|
|
if (!byUser[userId]) {
|
|
byUser[userId] = {
|
|
name: assignment.user.name || assignment.user.email || 'Unknown',
|
|
assigned: 0,
|
|
completed: 0,
|
|
}
|
|
}
|
|
byUser[userId].assigned++
|
|
if (assignment.evaluation?.status === 'SUBMITTED') {
|
|
byUser[userId].completed++
|
|
}
|
|
})
|
|
|
|
return Object.entries(byUser)
|
|
.map(([id, data]) => ({
|
|
id,
|
|
...data,
|
|
completionRate:
|
|
data.assigned > 0
|
|
? Math.round((data.completed / data.assigned) * 100)
|
|
: 0,
|
|
}))
|
|
.sort((a, b) => b.assigned - a.assigned)
|
|
}),
|
|
|
|
/**
|
|
* Get project rankings with average scores
|
|
*/
|
|
getProjectRankings: adminProcedure
|
|
.input(z.object({ roundId: z.string(), limit: z.number().optional() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const roundProjects = await ctx.prisma.roundProject.findMany({
|
|
where: { roundId: input.roundId },
|
|
include: {
|
|
project: {
|
|
include: {
|
|
assignments: {
|
|
include: {
|
|
evaluation: {
|
|
select: { criterionScoresJson: true, status: true },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
// Calculate average scores
|
|
const rankings = roundProjects
|
|
.map((rp) => {
|
|
const project = rp.project
|
|
const allScores: number[] = []
|
|
|
|
project.assignments.forEach((assignment) => {
|
|
const evaluation = assignment.evaluation
|
|
if (evaluation?.status === 'SUBMITTED') {
|
|
const scores = evaluation.criterionScoresJson as Record<
|
|
string,
|
|
number
|
|
> | null
|
|
if (scores) {
|
|
const scoreValues = Object.values(scores).filter(
|
|
(s): s is number => typeof s === 'number'
|
|
)
|
|
if (scoreValues.length > 0) {
|
|
const average =
|
|
scoreValues.reduce((a, b) => a + b, 0) / scoreValues.length
|
|
allScores.push(average)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
const averageScore =
|
|
allScores.length > 0
|
|
? allScores.reduce((a, b) => a + b, 0) / allScores.length
|
|
: null
|
|
|
|
return {
|
|
id: project.id,
|
|
title: project.title,
|
|
teamName: project.teamName,
|
|
status: rp.status,
|
|
averageScore,
|
|
evaluationCount: allScores.length,
|
|
}
|
|
})
|
|
.filter((p) => p.averageScore !== null)
|
|
.sort((a, b) => (b.averageScore || 0) - (a.averageScore || 0))
|
|
|
|
return input.limit ? rankings.slice(0, input.limit) : rankings
|
|
}),
|
|
|
|
/**
|
|
* Get status breakdown (pie chart data)
|
|
*/
|
|
getStatusBreakdown: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const roundProjects = await ctx.prisma.roundProject.groupBy({
|
|
by: ['status'],
|
|
where: { roundId: input.roundId },
|
|
_count: true,
|
|
})
|
|
|
|
return roundProjects.map((rp) => ({
|
|
status: rp.status,
|
|
count: rp._count,
|
|
}))
|
|
}),
|
|
|
|
/**
|
|
* Get overview stats for dashboard
|
|
*/
|
|
getOverviewStats: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const [
|
|
projectCount,
|
|
assignmentCount,
|
|
evaluationCount,
|
|
jurorCount,
|
|
statusCounts,
|
|
] = await Promise.all([
|
|
ctx.prisma.roundProject.count({ where: { roundId: input.roundId } }),
|
|
ctx.prisma.assignment.count({ where: { roundId: input.roundId } }),
|
|
ctx.prisma.evaluation.count({
|
|
where: {
|
|
assignment: { roundId: input.roundId },
|
|
status: 'SUBMITTED',
|
|
},
|
|
}),
|
|
ctx.prisma.assignment.groupBy({
|
|
by: ['userId'],
|
|
where: { roundId: input.roundId },
|
|
}),
|
|
ctx.prisma.roundProject.groupBy({
|
|
by: ['status'],
|
|
where: { roundId: input.roundId },
|
|
_count: true,
|
|
}),
|
|
])
|
|
|
|
const completionRate =
|
|
assignmentCount > 0
|
|
? Math.round((evaluationCount / assignmentCount) * 100)
|
|
: 0
|
|
|
|
return {
|
|
projectCount,
|
|
assignmentCount,
|
|
evaluationCount,
|
|
jurorCount: jurorCount.length,
|
|
completionRate,
|
|
statusBreakdown: statusCounts.map((s) => ({
|
|
status: s.status,
|
|
count: s._count,
|
|
})),
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Get criteria-level score distribution
|
|
*/
|
|
getCriteriaScores: adminProcedure
|
|
.input(z.object({ roundId: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
// Get active evaluation form for this round
|
|
const evaluationForm = await ctx.prisma.evaluationForm.findFirst({
|
|
where: { roundId: input.roundId, isActive: true },
|
|
})
|
|
|
|
if (!evaluationForm?.criteriaJson) {
|
|
return []
|
|
}
|
|
|
|
// Parse criteria from JSON
|
|
const criteria = evaluationForm.criteriaJson as Array<{
|
|
id: string
|
|
label: string
|
|
}>
|
|
|
|
if (!criteria || criteria.length === 0) {
|
|
return []
|
|
}
|
|
|
|
// Get all evaluations
|
|
const evaluations = await ctx.prisma.evaluation.findMany({
|
|
where: {
|
|
assignment: { roundId: input.roundId },
|
|
status: 'SUBMITTED',
|
|
},
|
|
select: { criterionScoresJson: true },
|
|
})
|
|
|
|
// Calculate average score per criterion
|
|
const criteriaScores = criteria.map((criterion) => {
|
|
const scores: number[] = []
|
|
|
|
evaluations.forEach((evaluation) => {
|
|
const criterionScoresJson = evaluation.criterionScoresJson as Record<
|
|
string,
|
|
number
|
|
> | null
|
|
if (criterionScoresJson && typeof criterionScoresJson[criterion.id] === 'number') {
|
|
scores.push(criterionScoresJson[criterion.id])
|
|
}
|
|
})
|
|
|
|
return {
|
|
id: criterion.id,
|
|
name: criterion.label,
|
|
averageScore:
|
|
scores.length > 0
|
|
? scores.reduce((a, b) => a + b, 0) / scores.length
|
|
: 0,
|
|
count: scores.length,
|
|
}
|
|
})
|
|
|
|
return criteriaScores
|
|
}),
|
|
|
|
/**
|
|
* Get geographic distribution of projects by country
|
|
*/
|
|
getGeographicDistribution: adminProcedure
|
|
.input(
|
|
z.object({
|
|
programId: z.string(),
|
|
roundId: z.string().optional(),
|
|
})
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const where = input.roundId
|
|
? { roundProjects: { some: { roundId: input.roundId } } }
|
|
: { programId: input.programId }
|
|
|
|
const distribution = await ctx.prisma.project.groupBy({
|
|
by: ['country'],
|
|
where,
|
|
_count: { id: true },
|
|
})
|
|
|
|
return distribution.map((d) => ({
|
|
countryCode: d.country || 'UNKNOWN',
|
|
count: d._count.id,
|
|
}))
|
|
}),
|
|
})
|