403 lines
15 KiB
TypeScript
403 lines
15 KiB
TypeScript
import { z } from "zod";
|
|
import { createTRPCRouter, controllerProcedure } from "../trpc.js";
|
|
import {
|
|
getDashboardChargeabilityOverview,
|
|
getDashboardDemand,
|
|
getDashboardOverview,
|
|
getDashboardPeakTimes,
|
|
getDashboardTopValueResources,
|
|
getDashboardBudgetForecast,
|
|
getDashboardSkillGaps,
|
|
getDashboardSkillGapSummary,
|
|
getDashboardProjectHealth,
|
|
} from "@capakraken/application";
|
|
import { anonymizeResources, getAnonymizationDirectory } from "../lib/anonymization.js";
|
|
import { cacheGet, cacheSet } from "../lib/cache.js";
|
|
import { fmtEur } from "../lib/format-utils.js";
|
|
|
|
const DEFAULT_TTL = 60; // seconds
|
|
|
|
function round1(value: number): number {
|
|
return Math.round(value * 10) / 10;
|
|
}
|
|
|
|
function mapProjectHealthDetailRows(rows: Awaited<ReturnType<typeof getDashboardProjectHealth>>) {
|
|
const projects = rows
|
|
.map((project) => {
|
|
const overall = project.compositeScore;
|
|
return {
|
|
projectId: project.id,
|
|
projectName: project.projectName,
|
|
shortCode: project.shortCode,
|
|
status: project.status,
|
|
overall,
|
|
budget: project.budgetHealth,
|
|
staffing: project.staffingHealth,
|
|
timeline: project.timelineHealth,
|
|
rating: overall >= 80 ? "healthy" : overall >= 50 ? "at_risk" : "critical",
|
|
};
|
|
})
|
|
.sort((left, right) => left.overall - right.overall);
|
|
|
|
return {
|
|
projects,
|
|
summary: {
|
|
healthy: projects.filter((project) => project.rating === "healthy").length,
|
|
atRisk: projects.filter((project) => project.rating === "at_risk").length,
|
|
critical: projects.filter((project) => project.rating === "critical").length,
|
|
},
|
|
};
|
|
}
|
|
|
|
function mapBudgetForecastDetailRows(rows: Awaited<ReturnType<typeof getDashboardBudgetForecast>>) {
|
|
return {
|
|
forecasts: rows.map((forecast) => ({
|
|
projectId: forecast.projectId ?? null,
|
|
projectName: forecast.projectName,
|
|
shortCode: forecast.shortCode,
|
|
clientId: forecast.clientId,
|
|
clientName: forecast.clientName,
|
|
budget: fmtEur(forecast.budgetCents),
|
|
budgetCents: forecast.budgetCents,
|
|
spent: fmtEur(forecast.spentCents),
|
|
spentCents: forecast.spentCents,
|
|
remaining: fmtEur(forecast.remainingCents ?? (forecast.budgetCents - forecast.spentCents)),
|
|
remainingCents: forecast.remainingCents ?? (forecast.budgetCents - forecast.spentCents),
|
|
projected: forecast.burnRate > 0
|
|
? fmtEur(forecast.spentCents + Math.max(0, forecast.budgetCents - forecast.spentCents))
|
|
: fmtEur(forecast.spentCents),
|
|
projectedCents: forecast.burnRate > 0
|
|
? Math.max(forecast.spentCents, forecast.budgetCents)
|
|
: forecast.spentCents,
|
|
burnRate: fmtEur(forecast.burnRate),
|
|
burnRateCents: forecast.burnRate,
|
|
utilization: `${forecast.pctUsed}%`,
|
|
estimatedExhaustionDate: forecast.estimatedExhaustionDate,
|
|
activeAssignmentCount: forecast.activeAssignmentCount ?? null,
|
|
calendarLocations: forecast.calendarLocations ?? [],
|
|
burnStatus: forecast.pctUsed >= 100
|
|
? "ahead"
|
|
: forecast.burnRate > 0
|
|
? "on_track"
|
|
: "not_started",
|
|
})),
|
|
};
|
|
}
|
|
|
|
function mapStatisticsDetail(overview: Awaited<ReturnType<typeof getDashboardOverview>>) {
|
|
return {
|
|
activeResources: overview.activeResources,
|
|
totalProjects: overview.totalProjects,
|
|
activeProjects: overview.activeProjects,
|
|
totalAllocations: overview.totalAllocations,
|
|
approvedVacations: overview.approvedVacations,
|
|
totalEstimates: overview.totalEstimates,
|
|
totalBudget: overview.budgetSummary.totalBudgetCents > 0
|
|
? fmtEur(overview.budgetSummary.totalBudgetCents)
|
|
: "N/A",
|
|
projectsByStatus: Object.fromEntries(
|
|
overview.projectsByStatus.map((entry) => [entry.status, entry.count]),
|
|
),
|
|
topChapters: [...overview.chapterUtilization]
|
|
.sort((left, right) => right.resourceCount - left.resourceCount)
|
|
.slice(0, 10)
|
|
.map((chapter) => ({
|
|
chapter: chapter.chapter,
|
|
count: chapter.resourceCount,
|
|
})),
|
|
};
|
|
}
|
|
|
|
async function getOverviewCached(db: Parameters<typeof getDashboardOverview>[0]) {
|
|
const cacheKey = "overview";
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardOverview>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardOverview(db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
async function getPeakTimesCached(
|
|
db: Parameters<typeof getDashboardPeakTimes>[0],
|
|
input: { startDate: string; endDate: string; granularity: "week" | "month"; groupBy: "project" | "chapter" | "resource" },
|
|
) {
|
|
const cacheKey = `peakTimes:${input.startDate}:${input.endDate}:${input.granularity}:${input.groupBy}`;
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardPeakTimes>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardPeakTimes(db, {
|
|
startDate: new Date(input.startDate),
|
|
endDate: new Date(input.endDate),
|
|
granularity: input.granularity,
|
|
groupBy: input.groupBy,
|
|
});
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
async function getDemandCached(
|
|
db: Parameters<typeof getDashboardDemand>[0],
|
|
input: { startDate: string; endDate: string; groupBy: "project" | "person" | "chapter" },
|
|
) {
|
|
const cacheKey = `demand:${input.startDate}:${input.endDate}:${input.groupBy}`;
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardDemand>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardDemand(db, {
|
|
startDate: new Date(input.startDate),
|
|
endDate: new Date(input.endDate),
|
|
groupBy: input.groupBy,
|
|
});
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
async function getTopValueResourcesCached(
|
|
db: Parameters<typeof getDashboardTopValueResources>[0],
|
|
input: { limit: number; userRole: string },
|
|
) {
|
|
const cacheKey = `topValue:${input.limit}:${input.userRole}`;
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof anonymizeResources>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const [resources, directory] = await Promise.all([
|
|
getDashboardTopValueResources(db, {
|
|
limit: input.limit,
|
|
userRole: input.userRole,
|
|
}),
|
|
getAnonymizationDirectory(db),
|
|
]);
|
|
const result = anonymizeResources(resources, directory);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
export const dashboardRouter = createTRPCRouter({
|
|
getOverview: controllerProcedure.query(async ({ ctx }) => {
|
|
return getOverviewCached(ctx.db);
|
|
}),
|
|
|
|
getStatisticsDetail: controllerProcedure.query(async ({ ctx }) => {
|
|
const overview = await getOverviewCached(ctx.db);
|
|
return mapStatisticsDetail(overview);
|
|
}),
|
|
|
|
getPeakTimes: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
startDate: z.string().datetime(),
|
|
endDate: z.string().datetime(),
|
|
granularity: z.enum(["week", "month"]).default("month"),
|
|
groupBy: z.enum(["project", "chapter", "resource"]).default("project"),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
return getPeakTimesCached(ctx.db, input);
|
|
}),
|
|
|
|
getTopValueResources: controllerProcedure
|
|
.input(z.object({ limit: z.number().int().min(1).max(50).default(10) }))
|
|
.query(async ({ ctx, input }) => {
|
|
const userRole =
|
|
(ctx.session.user as { role?: string } | undefined)?.role ?? "USER";
|
|
return getTopValueResourcesCached(ctx.db, { limit: input.limit, userRole });
|
|
}),
|
|
|
|
getDemand: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
startDate: z.string().datetime(),
|
|
endDate: z.string().datetime(),
|
|
groupBy: z.enum(["project", "person", "chapter"]).default("project"),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
return getDemandCached(ctx.db, input);
|
|
}),
|
|
|
|
getDetail: controllerProcedure
|
|
.input(z.object({ section: z.string().optional().default("all") }))
|
|
.query(async ({ ctx, input }) => {
|
|
const section = input.section;
|
|
const result: Record<string, unknown> = {};
|
|
const needsOverview =
|
|
section === "all"
|
|
|| section === "peak_times"
|
|
|| section === "demand_pipeline"
|
|
|| section === "chargeability_overview";
|
|
const overview = needsOverview ? await getOverviewCached(ctx.db) : null;
|
|
const now = new Date();
|
|
const rangeStart = overview?.budgetBasis.windowStart
|
|
? new Date(overview.budgetBasis.windowStart)
|
|
: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
|
|
const rangeEnd = overview?.budgetBasis.windowEnd
|
|
? new Date(overview.budgetBasis.windowEnd)
|
|
: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 5, 0));
|
|
const userRole =
|
|
(ctx.session.user as { role?: string } | undefined)?.role
|
|
?? ctx.dbUser?.systemRole
|
|
?? "USER";
|
|
|
|
if (section === "all" || section === "peak_times") {
|
|
const peakTimes = await getPeakTimesCached(ctx.db, {
|
|
startDate: rangeStart.toISOString(),
|
|
endDate: rangeEnd.toISOString(),
|
|
granularity: "month",
|
|
groupBy: "project",
|
|
});
|
|
|
|
result.peakTimes = [...peakTimes]
|
|
.sort((left, right) => right.totalHours - left.totalHours)
|
|
.slice(0, 6)
|
|
.map((entry) => ({
|
|
month: entry.period,
|
|
totalHours: round1(entry.totalHours),
|
|
totalHoursPerDay: round1(entry.totalHours),
|
|
capacityHours: round1(entry.capacityHours),
|
|
utilizationPct: entry.utilizationPct ?? null,
|
|
}));
|
|
}
|
|
|
|
if (section === "all" || section === "top_resources") {
|
|
const resources = await getTopValueResourcesCached(ctx.db, { limit: 10, userRole });
|
|
result.topResources = resources.map((resource) => {
|
|
const topResource = resource as {
|
|
displayName: string;
|
|
eid: string;
|
|
chapter: string | null;
|
|
lcrCents: number;
|
|
valueScore: number | null;
|
|
};
|
|
return {
|
|
name: topResource.displayName,
|
|
eid: topResource.eid,
|
|
chapter: topResource.chapter ?? null,
|
|
lcr: fmtEur(topResource.lcrCents),
|
|
valueScore: topResource.valueScore ?? null,
|
|
};
|
|
});
|
|
}
|
|
|
|
if (section === "all" || section === "demand_pipeline") {
|
|
const demandRows = await getDemandCached(ctx.db, {
|
|
startDate: rangeStart.toISOString(),
|
|
endDate: rangeEnd.toISOString(),
|
|
groupBy: "project",
|
|
});
|
|
result.demandPipeline = demandRows
|
|
.map((row) => ({
|
|
project: `${row.name} (${row.shortCode})`,
|
|
needed: Math.max(0, round1(row.requiredFTEs - row.resourceCount)),
|
|
requiredFTEs: row.requiredFTEs,
|
|
allocatedResources: row.resourceCount,
|
|
allocatedHours: row.allocatedHours,
|
|
calendarLocations: row.derivation?.calendarLocations ?? [],
|
|
}))
|
|
.filter((row) => row.needed > 0)
|
|
.sort((left, right) => right.needed - left.needed)
|
|
.slice(0, 15);
|
|
}
|
|
|
|
if (section === "all" || section === "chargeability_overview") {
|
|
result.chargeabilityByChapter = (overview?.chapterUtilization ?? []).map((chapter) => ({
|
|
chapter: chapter.chapter ?? "Unassigned",
|
|
headcount: chapter.resourceCount,
|
|
avgTarget: `${Math.round(chapter.avgChargeabilityTarget)}%`,
|
|
}));
|
|
}
|
|
|
|
return result;
|
|
}),
|
|
|
|
getChargeabilityOverview: controllerProcedure
|
|
.input(
|
|
z.object({
|
|
includeProposed: z.boolean().default(false),
|
|
topN: z.number().int().min(1).max(50).default(10),
|
|
watchlistThreshold: z.number().default(15),
|
|
countryIds: z.array(z.string()).optional(),
|
|
departed: z.boolean().optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const cacheKey = `chargeability:${input.includeProposed}:${input.topN}:${input.watchlistThreshold}:${(input.countryIds ?? []).join(",")}:${input.departed ?? ""}`;
|
|
type ChargeResult = Awaited<ReturnType<typeof getDashboardChargeabilityOverview>>;
|
|
const cached = await cacheGet<{
|
|
top: unknown[];
|
|
watchlist: unknown[];
|
|
[key: string]: unknown;
|
|
}>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const [overview, directory] = await Promise.all([
|
|
getDashboardChargeabilityOverview(ctx.db, {
|
|
includeProposed: input.includeProposed,
|
|
topN: input.topN,
|
|
watchlistThreshold: input.watchlistThreshold,
|
|
...(input.countryIds !== undefined ? { countryIds: input.countryIds } : {}),
|
|
...(input.departed !== undefined ? { departed: input.departed } : {}),
|
|
}),
|
|
getAnonymizationDirectory(ctx.db),
|
|
]);
|
|
|
|
const result = {
|
|
...overview,
|
|
top: anonymizeResources(overview.top, directory),
|
|
watchlist: anonymizeResources(overview.watchlist, directory),
|
|
};
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}),
|
|
|
|
getBudgetForecast: controllerProcedure.query(async ({ ctx }) => {
|
|
const cacheKey = "budgetForecast";
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardBudgetForecast>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardBudgetForecast(ctx.db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}),
|
|
|
|
getBudgetForecastDetail: controllerProcedure.query(async ({ ctx }) => {
|
|
const budgetForecast = await getDashboardBudgetForecast(ctx.db);
|
|
return mapBudgetForecastDetailRows(budgetForecast);
|
|
}),
|
|
|
|
getSkillGaps: controllerProcedure.query(async ({ ctx }) => {
|
|
const cacheKey = "skillGaps";
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardSkillGaps>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardSkillGaps(ctx.db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}),
|
|
|
|
getSkillGapSummary: controllerProcedure.query(async ({ ctx }) => {
|
|
const cacheKey = "skillGapSummary";
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardSkillGapSummary>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardSkillGapSummary(ctx.db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}),
|
|
|
|
getProjectHealth: controllerProcedure.query(async ({ ctx }) => {
|
|
const cacheKey = "projectHealth";
|
|
const cached = await cacheGet<Awaited<ReturnType<typeof getDashboardProjectHealth>>>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardProjectHealth(ctx.db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}),
|
|
|
|
getProjectHealthDetail: controllerProcedure.query(async ({ ctx }) => {
|
|
const projectHealth = await getDashboardProjectHealth(ctx.db);
|
|
return mapProjectHealthDetailRows(projectHealth);
|
|
}),
|
|
});
|