375 lines
13 KiB
TypeScript
375 lines
13 KiB
TypeScript
import {
|
|
isChargeabilityActualBooking,
|
|
isChargeabilityRelevantProject,
|
|
listAssignmentBookings,
|
|
} from "@capakraken/application";
|
|
import { TRPCError } from "@trpc/server";
|
|
import type { WeekdayAvailability } from "@capakraken/shared";
|
|
import { z } from "zod";
|
|
import { controllerProcedure } from "../trpc.js";
|
|
import {
|
|
calculateEffectiveAvailableHours,
|
|
calculateEffectiveBookedHours,
|
|
countEffectiveWorkingDays,
|
|
getAvailabilityHoursForDate,
|
|
loadResourceDailyAvailabilityContexts,
|
|
} from "../lib/resource-capacity.js";
|
|
import {
|
|
buildSelect,
|
|
buildWhere,
|
|
csvEscape,
|
|
type EntityKey,
|
|
flattenRow,
|
|
getValidScalarField,
|
|
reportEntitySchema,
|
|
ReportInputSchema,
|
|
type ReportInput,
|
|
type ReportQueryResult,
|
|
validateReportInput,
|
|
} from "./report-query-config.js";
|
|
import { COLUMN_MAP, RESOURCE_MONTH_COLUMNS } from "./report-columns.js";
|
|
import {
|
|
buildReportGroups,
|
|
matchesInMemoryFilter,
|
|
pickColumns,
|
|
sortInMemoryRows,
|
|
} from "./report-query-utils.js";
|
|
|
|
export const reportQueryProcedures = {
|
|
getAvailableColumns: controllerProcedure
|
|
.input(z.object({ entity: reportEntitySchema }))
|
|
.query(({ input }) => {
|
|
const columns = COLUMN_MAP[input.entity];
|
|
if (!columns) {
|
|
throw new TRPCError({ code: "BAD_REQUEST", message: `Unknown entity: ${input.entity}` });
|
|
}
|
|
return columns.map(({ key, label, dataType }) => ({ key, label, dataType }));
|
|
}),
|
|
|
|
getReportData: controllerProcedure
|
|
.input(ReportInputSchema)
|
|
.query(async ({ ctx, input }) => executeReportQuery(ctx.db, input)),
|
|
|
|
exportReport: controllerProcedure
|
|
.input(ReportInputSchema.omit({ offset: true }).extend({
|
|
limit: z.number().int().min(1).max(50000).default(5000),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const result = await executeReportQuery(ctx.db, { ...input, offset: 0 });
|
|
const outputColumns = result.columns;
|
|
const entityColumns = COLUMN_MAP[input.entity];
|
|
const headerLabels = outputColumns.map((key) => {
|
|
const def = entityColumns.find((column) => column.key === key);
|
|
return def?.label ?? key;
|
|
});
|
|
|
|
const csvLines = [headerLabels.map(csvEscape).join(",")];
|
|
const groupByLabel = input.groupBy
|
|
? entityColumns.find((column) => column.key === input.groupBy)?.label ?? input.groupBy
|
|
: null;
|
|
const groupStartByIndex = new Map(
|
|
result.groups.map((group) => [group.startIndex, group] as const),
|
|
);
|
|
|
|
result.rows.forEach((row, index) => {
|
|
const group = groupStartByIndex.get(index);
|
|
if (group && groupByLabel) {
|
|
csvLines.push(outputColumns.map((_, columnIndex) => (
|
|
columnIndex === 0 ? csvEscape(`${groupByLabel}: ${group.label} (${group.rowCount})`) : ""
|
|
)).join(","));
|
|
}
|
|
|
|
csvLines.push(outputColumns.map((column) => csvEscape(row[column])).join(","));
|
|
});
|
|
|
|
return { csv: csvLines.join("\n"), rowCount: result.rows.length };
|
|
}),
|
|
};
|
|
|
|
async function executeReportQuery(
|
|
db: any,
|
|
input: ReportInput,
|
|
): Promise<ReportQueryResult> {
|
|
validateReportInput(input);
|
|
|
|
if (input.entity === "resource_month") {
|
|
return executeResourceMonthReport(db, input);
|
|
}
|
|
|
|
const { entity, columns, filters, sortBy, sortDir, limit, offset } = input;
|
|
const select = buildSelect(entity, columns);
|
|
const where = buildWhere(entity, filters);
|
|
|
|
const orderBy: Record<string, string>[] = [];
|
|
if (input.groupBy) {
|
|
const groupField = getValidScalarField(entity, input.groupBy);
|
|
if (!groupField) {
|
|
throw new TRPCError({
|
|
code: "BAD_REQUEST",
|
|
message: `Unsupported group field for ${entity}: ${input.groupBy}`,
|
|
});
|
|
}
|
|
orderBy.push({ [groupField]: "asc" });
|
|
}
|
|
if (sortBy) {
|
|
const validField = getValidScalarField(entity, sortBy);
|
|
if (!validField) {
|
|
throw new TRPCError({
|
|
code: "BAD_REQUEST",
|
|
message: `Unsupported sort field for ${entity}: ${sortBy}`,
|
|
});
|
|
}
|
|
orderBy.push({ [validField]: sortDir });
|
|
}
|
|
|
|
const modelDelegate = getModelDelegate(db, entity);
|
|
const [rawRows, totalCount] = await Promise.all([
|
|
modelDelegate.findMany({
|
|
select,
|
|
where,
|
|
...(orderBy.length > 0 ? { orderBy } : {}),
|
|
take: limit,
|
|
skip: offset,
|
|
}),
|
|
modelDelegate.count({ where }),
|
|
]);
|
|
|
|
const flattenedRows = rawRows.map((row: Record<string, unknown>) => flattenRow(row));
|
|
const rows = sortInMemoryRows(flattenedRows, input.groupBy, sortBy, sortDir, COLUMN_MAP[entity]);
|
|
const outputColumns = ["id", ...columns.filter((column) => column !== "id")];
|
|
const groups = buildReportGroups(rows, input.groupBy);
|
|
|
|
return {
|
|
rows: rows.map((row) => pickColumns(row, outputColumns)),
|
|
columns: outputColumns,
|
|
totalCount,
|
|
groups,
|
|
};
|
|
}
|
|
|
|
async function executeResourceMonthReport(
|
|
db: any,
|
|
input: ReportInput,
|
|
): Promise<ReportQueryResult> {
|
|
const periodMonth = input.periodMonth ?? new Date().toISOString().slice(0, 7);
|
|
const [year, month] = periodMonth.split("-").map(Number) as [number, number];
|
|
const periodStart = new Date(Date.UTC(year, month - 1, 1));
|
|
const periodEnd = new Date(Date.UTC(year, month, 0));
|
|
|
|
const resources = await db.resource.findMany({
|
|
select: {
|
|
id: true,
|
|
eid: true,
|
|
displayName: true,
|
|
email: true,
|
|
chapter: true,
|
|
resourceType: true,
|
|
isActive: true,
|
|
chgResponsibility: true,
|
|
rolledOff: true,
|
|
departed: true,
|
|
lcrCents: true,
|
|
ucrCents: true,
|
|
currency: true,
|
|
fte: true,
|
|
availability: true,
|
|
chargeabilityTarget: true,
|
|
federalState: true,
|
|
countryId: true,
|
|
metroCityId: true,
|
|
country: { select: { code: true, name: true } },
|
|
metroCity: { select: { name: true } },
|
|
orgUnit: { select: { name: true } },
|
|
managementLevelGroup: { select: { name: true, targetPercentage: true } },
|
|
managementLevel: { select: { name: true } },
|
|
},
|
|
orderBy: { displayName: "asc" },
|
|
});
|
|
|
|
const resourceIds = resources.map((resource: any) => resource.id);
|
|
const [bookings, contexts] = await Promise.all([
|
|
resourceIds.length > 0
|
|
? listAssignmentBookings(db, {
|
|
startDate: periodStart,
|
|
endDate: periodEnd,
|
|
resourceIds,
|
|
})
|
|
: Promise.resolve([]),
|
|
loadResourceDailyAvailabilityContexts(
|
|
db,
|
|
resources.map((resource: any) => ({
|
|
id: resource.id,
|
|
availability: resource.availability as WeekdayAvailability,
|
|
countryId: resource.countryId,
|
|
countryCode: resource.country?.code,
|
|
federalState: resource.federalState,
|
|
metroCityId: resource.metroCityId,
|
|
metroCityName: resource.metroCity?.name,
|
|
})),
|
|
periodStart,
|
|
periodEnd,
|
|
),
|
|
]);
|
|
|
|
const rows = resources.map((resource: any) => {
|
|
const availability = resource.availability as WeekdayAvailability;
|
|
const context = contexts.get(resource.id);
|
|
const resourceBookings = bookings.filter((booking) => booking.resourceId === resource.id);
|
|
const baseWorkingDays = countEffectiveWorkingDays({
|
|
availability,
|
|
periodStart,
|
|
periodEnd,
|
|
context: undefined,
|
|
});
|
|
const effectiveWorkingDays = countEffectiveWorkingDays({
|
|
availability,
|
|
periodStart,
|
|
periodEnd,
|
|
context,
|
|
});
|
|
const baseAvailableHours = calculateEffectiveAvailableHours({
|
|
availability,
|
|
periodStart,
|
|
periodEnd,
|
|
context: undefined,
|
|
});
|
|
const sahHours = calculateEffectiveAvailableHours({
|
|
availability,
|
|
periodStart,
|
|
periodEnd,
|
|
context,
|
|
});
|
|
|
|
const holidayDates = [...(context?.holidayDates ?? new Set<string>())];
|
|
const publicHolidayWorkdayCount = holidayDates.reduce((count, isoDate) => (
|
|
count + (getAvailabilityHoursForDate(availability, new Date(`${isoDate}T00:00:00.000Z`)) > 0 ? 1 : 0)
|
|
), 0);
|
|
const publicHolidayHoursDeduction = holidayDates.reduce((sum, isoDate) => (
|
|
sum + getAvailabilityHoursForDate(availability, new Date(`${isoDate}T00:00:00.000Z`))
|
|
), 0);
|
|
|
|
let absenceDayEquivalent = 0;
|
|
let absenceHoursDeduction = 0;
|
|
for (const [isoDate, fraction] of context?.vacationFractionsByDate ?? []) {
|
|
const dayHours = getAvailabilityHoursForDate(availability, new Date(`${isoDate}T00:00:00.000Z`));
|
|
if (dayHours <= 0 || context?.holidayDates.has(isoDate)) {
|
|
continue;
|
|
}
|
|
absenceDayEquivalent += fraction;
|
|
absenceHoursDeduction += dayHours * fraction;
|
|
}
|
|
|
|
const actualBookedHours = resourceBookings
|
|
.filter((booking) => isChargeabilityActualBooking(booking, false))
|
|
.reduce((sum, booking) => sum + calculateEffectiveBookedHours({
|
|
availability,
|
|
startDate: booking.startDate,
|
|
endDate: booking.endDate,
|
|
hoursPerDay: booking.hoursPerDay,
|
|
periodStart,
|
|
periodEnd,
|
|
context,
|
|
}), 0);
|
|
const expectedBookedHours = resourceBookings
|
|
.filter((booking) => isChargeabilityRelevantProject(booking.project, true))
|
|
.reduce((sum, booking) => sum + calculateEffectiveBookedHours({
|
|
availability,
|
|
startDate: booking.startDate,
|
|
endDate: booking.endDate,
|
|
hoursPerDay: booking.hoursPerDay,
|
|
periodStart,
|
|
periodEnd,
|
|
context,
|
|
}), 0);
|
|
|
|
const targetPct = resource.managementLevelGroup?.targetPercentage != null
|
|
? resource.managementLevelGroup.targetPercentage * 100
|
|
: resource.chargeabilityTarget;
|
|
|
|
return {
|
|
id: `${resource.id}:${periodMonth}`,
|
|
resourceId: resource.id,
|
|
monthKey: periodMonth,
|
|
periodStart: periodStart.toISOString(),
|
|
periodEnd: periodEnd.toISOString(),
|
|
eid: resource.eid,
|
|
displayName: resource.displayName,
|
|
email: resource.email,
|
|
chapter: resource.chapter,
|
|
resourceType: resource.resourceType,
|
|
isActive: resource.isActive,
|
|
chgResponsibility: resource.chgResponsibility,
|
|
rolledOff: resource.rolledOff,
|
|
departed: resource.departed,
|
|
countryCode: resource.country?.code ?? null,
|
|
countryName: resource.country?.name ?? null,
|
|
federalState: resource.federalState,
|
|
metroCityName: resource.metroCity?.name ?? null,
|
|
orgUnitName: resource.orgUnit?.name ?? null,
|
|
managementLevelGroupName: resource.managementLevelGroup?.name ?? null,
|
|
managementLevelName: resource.managementLevel?.name ?? null,
|
|
fte: roundMetric(resource.fte),
|
|
lcrCents: resource.lcrCents,
|
|
ucrCents: resource.ucrCents,
|
|
currency: resource.currency,
|
|
monthlyChargeabilityTargetPct: roundMetric(targetPct),
|
|
monthlyTargetHours: roundMetric((sahHours * targetPct) / 100),
|
|
monthlyBaseWorkingDays: roundMetric(baseWorkingDays),
|
|
monthlyEffectiveWorkingDays: roundMetric(effectiveWorkingDays),
|
|
monthlyBaseAvailableHours: roundMetric(baseAvailableHours),
|
|
monthlySahHours: roundMetric(sahHours),
|
|
monthlyPublicHolidayCount: holidayDates.length,
|
|
monthlyPublicHolidayWorkdayCount: publicHolidayWorkdayCount,
|
|
monthlyPublicHolidayHoursDeduction: roundMetric(publicHolidayHoursDeduction),
|
|
monthlyAbsenceDayEquivalent: roundMetric(absenceDayEquivalent),
|
|
monthlyAbsenceHoursDeduction: roundMetric(absenceHoursDeduction),
|
|
monthlyActualBookedHours: roundMetric(actualBookedHours),
|
|
monthlyExpectedBookedHours: roundMetric(expectedBookedHours),
|
|
monthlyActualChargeabilityPct: roundMetric(sahHours > 0 ? (actualBookedHours / sahHours) * 100 : 0),
|
|
monthlyExpectedChargeabilityPct: roundMetric(sahHours > 0 ? (expectedBookedHours / sahHours) * 100 : 0),
|
|
monthlyUnassignedHours: roundMetric(Math.max(0, sahHours - actualBookedHours)),
|
|
};
|
|
});
|
|
|
|
const filteredRows = rows.filter((row: Record<string, unknown>) => input.filters.every((filter) => matchesInMemoryFilter(
|
|
row,
|
|
filter,
|
|
RESOURCE_MONTH_COLUMNS,
|
|
)));
|
|
const sortedRows = sortInMemoryRows(
|
|
filteredRows,
|
|
input.groupBy,
|
|
input.sortBy,
|
|
input.sortDir,
|
|
RESOURCE_MONTH_COLUMNS,
|
|
);
|
|
const totalCount = sortedRows.length;
|
|
const pagedRows = sortedRows.slice(input.offset, input.offset + input.limit);
|
|
const outputColumns = ["id", ...input.columns.filter((column) => column !== "id")];
|
|
const groups = buildReportGroups(pagedRows, input.groupBy);
|
|
|
|
return {
|
|
rows: pagedRows.map((row) => pickColumns(row, outputColumns)),
|
|
columns: outputColumns,
|
|
totalCount,
|
|
groups,
|
|
};
|
|
}
|
|
|
|
function roundMetric(value: number): number {
|
|
return Math.round(value * 10) / 10;
|
|
}
|
|
|
|
function getModelDelegate(db: any, entity: EntityKey) {
|
|
switch (entity) {
|
|
case "resource":
|
|
return db.resource;
|
|
case "project":
|
|
return db.project;
|
|
case "assignment":
|
|
return db.assignment;
|
|
default:
|
|
throw new TRPCError({ code: "BAD_REQUEST", message: `Unknown entity: ${entity}` });
|
|
}
|
|
}
|