381 lines
13 KiB
TypeScript
381 lines
13 KiB
TypeScript
import {
|
|
type BudgetForecastRow,
|
|
getDashboardBudgetForecast,
|
|
getDashboardChargeabilityOverview,
|
|
getDashboardDemand,
|
|
getDashboardOverview,
|
|
getDashboardPeakTimes,
|
|
getDashboardProjectHealth,
|
|
getDashboardSkillGaps,
|
|
getDashboardSkillGapSummary,
|
|
getDashboardTopValueResources,
|
|
} from "@capakraken/application";
|
|
import { z } from "zod";
|
|
import { anonymizeResources, getAnonymizationDirectory } from "../lib/anonymization.js";
|
|
import { cacheGet, cacheSet } from "../lib/cache.js";
|
|
import { fmtEur } from "../lib/format-utils.js";
|
|
import type { TRPCContext } from "../trpc.js";
|
|
import {
|
|
type DashboardBudgetForecastDetail,
|
|
mapBudgetForecastDetailRows,
|
|
mapProjectHealthDetailRows,
|
|
} from "./dashboard-detail-support.js";
|
|
|
|
const DEFAULT_TTL = 60;
|
|
|
|
type DashboardProcedureContext = Pick<TRPCContext, "db" | "dbUser" | "session">;
|
|
|
|
type TopValueResourceRow = {
|
|
id: string;
|
|
eid: string;
|
|
displayName: string;
|
|
chapter: string | null;
|
|
valueScore: number | null;
|
|
valueScoreBreakdown: import("@capakraken/shared").ValueScoreBreakdown | null;
|
|
valueScoreUpdatedAt: Date | null;
|
|
lcrCents: number;
|
|
countryCode: string | null;
|
|
countryName: string | null;
|
|
federalState: string | null;
|
|
metroCityName: string | null;
|
|
};
|
|
|
|
export const dashboardPeakTimesInputSchema = 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"),
|
|
});
|
|
|
|
export const dashboardTopValueResourcesInputSchema = z.object({
|
|
limit: z.number().int().min(1).max(50).default(10),
|
|
});
|
|
|
|
export const dashboardDemandInputSchema = z.object({
|
|
startDate: z.string().datetime(),
|
|
endDate: z.string().datetime(),
|
|
groupBy: z.enum(["project", "person", "chapter"]).default("project"),
|
|
});
|
|
|
|
export const dashboardDetailInputSchema = z.object({
|
|
section: z.string().optional().default("all"),
|
|
});
|
|
|
|
export const dashboardChargeabilityOverviewInputSchema = 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(),
|
|
});
|
|
|
|
type DashboardPeakTimesInput = z.infer<typeof dashboardPeakTimesInputSchema>;
|
|
type DashboardTopValueResourcesInput = z.infer<typeof dashboardTopValueResourcesInputSchema>;
|
|
type DashboardDemandInput = z.infer<typeof dashboardDemandInputSchema>;
|
|
type DashboardDetailInput = z.infer<typeof dashboardDetailInputSchema>;
|
|
type DashboardChargeabilityOverviewInput = z.infer<typeof dashboardChargeabilityOverviewInputSchema>;
|
|
|
|
function round1(value: number): number {
|
|
return Math.round(value * 10) / 10;
|
|
}
|
|
|
|
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: DashboardPeakTimesInput,
|
|
) {
|
|
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: DashboardDemandInput,
|
|
) {
|
|
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 },
|
|
): Promise<TopValueResourceRow[]> {
|
|
const cacheKey = `topValue:${input.limit}:${input.userRole}`;
|
|
const cached = await cacheGet<TopValueResourceRow[]>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const [resources, directory] = await Promise.all([
|
|
getDashboardTopValueResources(db, {
|
|
limit: input.limit,
|
|
userRole: input.userRole,
|
|
}),
|
|
getAnonymizationDirectory(db),
|
|
]);
|
|
const result: TopValueResourceRow[] = anonymizeResources(resources, directory);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
function getUserRole(ctx: DashboardProcedureContext) {
|
|
return (ctx.session?.user as { role?: string } | undefined)?.role
|
|
?? ctx.dbUser?.systemRole
|
|
?? "USER";
|
|
}
|
|
|
|
export async function getDashboardOverviewRead(ctx: DashboardProcedureContext) {
|
|
return getOverviewCached(ctx.db);
|
|
}
|
|
|
|
export async function getDashboardStatisticsDetail(ctx: DashboardProcedureContext) {
|
|
const overview = await getOverviewCached(ctx.db);
|
|
return mapStatisticsDetail(overview);
|
|
}
|
|
|
|
export async function getDashboardPeakTimesRead(
|
|
ctx: DashboardProcedureContext,
|
|
input: DashboardPeakTimesInput,
|
|
) {
|
|
return getPeakTimesCached(ctx.db, input);
|
|
}
|
|
|
|
export async function getDashboardTopValueResourcesRead(
|
|
ctx: DashboardProcedureContext,
|
|
input: DashboardTopValueResourcesInput,
|
|
) {
|
|
return getTopValueResourcesCached(ctx.db, { limit: input.limit, userRole: getUserRole(ctx) });
|
|
}
|
|
|
|
export async function getDashboardDemandRead(
|
|
ctx: DashboardProcedureContext,
|
|
input: DashboardDemandInput,
|
|
) {
|
|
return getDemandCached(ctx.db, input);
|
|
}
|
|
|
|
export async function getDashboardDetail(ctx: DashboardProcedureContext, input: DashboardDetailInput) {
|
|
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 = getUserRole(ctx);
|
|
|
|
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,
|
|
calendarContextCount: entry.derivation?.calendarContextCount ?? 0,
|
|
calendarLocations: entry.derivation?.calendarLocations ?? [],
|
|
}));
|
|
}
|
|
|
|
if (section === "all" || section === "top_resources") {
|
|
const resources = await getTopValueResourcesCached(ctx.db, { limit: 10, userRole });
|
|
result.topResources = resources.map((resource) => ({
|
|
name: resource.displayName,
|
|
eid: resource.eid,
|
|
chapter: resource.chapter ?? null,
|
|
lcr: fmtEur(resource.lcrCents),
|
|
valueScore: resource.valueScore ?? null,
|
|
valueScoreBreakdown: resource.valueScoreBreakdown ?? null,
|
|
valueScoreUpdatedAt: resource.valueScoreUpdatedAt?.toISOString() ?? null,
|
|
countryCode: resource.countryCode ?? null,
|
|
countryName: resource.countryName ?? null,
|
|
federalState: resource.federalState ?? null,
|
|
metroCityName: resource.metroCityName ?? 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;
|
|
}
|
|
|
|
export async function getDashboardChargeabilityOverviewRead(
|
|
ctx: DashboardProcedureContext,
|
|
input: DashboardChargeabilityOverviewInput,
|
|
) {
|
|
const cacheKey = `chargeability:${input.includeProposed}:${input.topN}:${input.watchlistThreshold}:${(input.countryIds ?? []).join(",")}:${input.departed ?? ""}`;
|
|
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;
|
|
}
|
|
|
|
export async function getDashboardBudgetForecastRead(
|
|
ctx: DashboardProcedureContext,
|
|
): Promise<BudgetForecastRow[]> {
|
|
const cacheKey = "budgetForecast";
|
|
const cached = await cacheGet<BudgetForecastRow[]>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
const result = await getDashboardBudgetForecast(ctx.db);
|
|
await cacheSet(cacheKey, result, DEFAULT_TTL);
|
|
return result;
|
|
}
|
|
|
|
export async function getDashboardBudgetForecastDetail(
|
|
ctx: DashboardProcedureContext,
|
|
): Promise<DashboardBudgetForecastDetail> {
|
|
const budgetForecast: BudgetForecastRow[] = await getDashboardBudgetForecast(ctx.db);
|
|
return mapBudgetForecastDetailRows(budgetForecast);
|
|
}
|
|
|
|
export async function getDashboardSkillGapsRead(ctx: DashboardProcedureContext) {
|
|
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;
|
|
}
|
|
|
|
export async function getDashboardSkillGapSummaryRead(ctx: DashboardProcedureContext) {
|
|
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;
|
|
}
|
|
|
|
export async function getDashboardProjectHealthRead(ctx: DashboardProcedureContext) {
|
|
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;
|
|
}
|
|
|
|
export async function getDashboardProjectHealthDetail(ctx: DashboardProcedureContext) {
|
|
const projectHealth = await getDashboardProjectHealth(ctx.db);
|
|
return mapProjectHealthDetailRows(projectHealth);
|
|
}
|