refactor(api): extract resource read procedures
This commit is contained in:
@@ -0,0 +1,555 @@
|
||||
import {
|
||||
calculateAllocation,
|
||||
deriveResourceForecast,
|
||||
getMonthRange,
|
||||
DEFAULT_CALCULATION_RULES,
|
||||
type AssignmentSlice,
|
||||
} from "@capakraken/engine";
|
||||
import { VacationStatus } from "@capakraken/db";
|
||||
import type { CalculationRule, SpainScheduleRule, WeekdayAvailability } from "@capakraken/shared";
|
||||
import { z } from "zod";
|
||||
import {
|
||||
asHolidayResolverDb,
|
||||
collectHolidayAvailability,
|
||||
getResolvedCalendarHolidays,
|
||||
} from "../lib/holiday-availability.js";
|
||||
import {
|
||||
calculateEffectiveAvailableHours,
|
||||
countEffectiveWorkingDays,
|
||||
loadResourceDailyAvailabilityContexts,
|
||||
} from "../lib/resource-capacity.js";
|
||||
import { assertCanReadResource } from "../lib/resource-access.js";
|
||||
import { protectedProcedure, resourceOverviewProcedure } from "../trpc.js";
|
||||
import {
|
||||
ResourceDirectoryQuerySchema,
|
||||
ResourceListQuerySchema,
|
||||
listStaffResources,
|
||||
mapResourceSummary,
|
||||
mapResourceSummaryDetail,
|
||||
readResourceSummariesSnapshot,
|
||||
readResourceSummaryDetailsSnapshot,
|
||||
} from "./resource-read-shared.js";
|
||||
|
||||
function getAvailabilityHoursForDate(
|
||||
availability: WeekdayAvailability,
|
||||
date: Date,
|
||||
): number {
|
||||
const dayKey = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"][date.getUTCDay()] as keyof WeekdayAvailability;
|
||||
return availability[dayKey] ?? 0;
|
||||
}
|
||||
|
||||
function sumAvailabilityHoursForDates(
|
||||
availability: WeekdayAvailability,
|
||||
dates: Date[],
|
||||
): number {
|
||||
return dates.reduce((sum, date) => sum + getAvailabilityHoursForDate(availability, date), 0);
|
||||
}
|
||||
|
||||
function formatResolvedHolidaySummary(holiday: {
|
||||
date: string;
|
||||
name: string;
|
||||
scope: string;
|
||||
calendarName: string | null;
|
||||
sourceType?: string | null;
|
||||
}) {
|
||||
return {
|
||||
date: holiday.date,
|
||||
name: holiday.name,
|
||||
scope: holiday.scope,
|
||||
calendarName: holiday.calendarName ?? "Built-in",
|
||||
sourceType: holiday.sourceType ?? "system",
|
||||
};
|
||||
}
|
||||
|
||||
function summarizeResolvedHolidaySummary(holidays: Array<ReturnType<typeof formatResolvedHolidaySummary>>) {
|
||||
const byScope = new Map<string, number>();
|
||||
const bySourceType = new Map<string, number>();
|
||||
const byCalendar = new Map<string, number>();
|
||||
|
||||
for (const holiday of holidays) {
|
||||
byScope.set(holiday.scope, (byScope.get(holiday.scope) ?? 0) + 1);
|
||||
bySourceType.set(holiday.sourceType, (bySourceType.get(holiday.sourceType) ?? 0) + 1);
|
||||
byCalendar.set(holiday.calendarName, (byCalendar.get(holiday.calendarName) ?? 0) + 1);
|
||||
}
|
||||
|
||||
return {
|
||||
byScope: [...byScope.entries()]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([scope, count]) => ({ scope, count })),
|
||||
bySourceType: [...bySourceType.entries()]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([sourceType, count]) => ({ sourceType, count })),
|
||||
byCalendar: [...byCalendar.entries()]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([calendarName, count]) => ({ calendarName, count })),
|
||||
};
|
||||
}
|
||||
|
||||
function round1(value: number): number {
|
||||
return Math.round(value * 10) / 10;
|
||||
}
|
||||
|
||||
function averagePerWorkingDay(totalHours: number, workingDays: number): number {
|
||||
return workingDays > 0 ? round1(totalHours / workingDays) : 0;
|
||||
}
|
||||
|
||||
export const resourceSummaryReadProcedures = {
|
||||
resolveResponsiblePersonName: resourceOverviewProcedure
|
||||
.input(z.object({ name: z.string() }))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const exact = await ctx.db.resource.findFirst({
|
||||
where: { displayName: { equals: input.name, mode: "insensitive" }, isActive: true },
|
||||
select: { displayName: true },
|
||||
});
|
||||
if (exact) {
|
||||
return {
|
||||
status: "resolved" as const,
|
||||
displayName: exact.displayName,
|
||||
};
|
||||
}
|
||||
|
||||
const candidates = await ctx.db.resource.findMany({
|
||||
where: { displayName: { contains: input.name, mode: "insensitive" }, isActive: true },
|
||||
select: { displayName: true, eid: true },
|
||||
take: 5,
|
||||
});
|
||||
if (candidates.length === 1) {
|
||||
return {
|
||||
status: "resolved" as const,
|
||||
displayName: candidates[0]!.displayName,
|
||||
};
|
||||
}
|
||||
if (candidates.length > 1) {
|
||||
return {
|
||||
status: "ambiguous" as const,
|
||||
message: `Multiple resources match "${input.name}": ${candidates.map((candidate) => `${candidate.displayName} (${candidate.eid})`).join(", ")}. Please specify the exact name.`,
|
||||
candidates,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
status: "missing" as const,
|
||||
message: `No active resource found matching "${input.name}". The responsible person must be an existing resource.`,
|
||||
candidates: [],
|
||||
};
|
||||
}),
|
||||
|
||||
getChargeabilitySummary: protectedProcedure
|
||||
.input(z.object({
|
||||
resourceId: z.string(),
|
||||
month: z.string().regex(/^\d{4}-\d{2}$/),
|
||||
}))
|
||||
.query(async ({ ctx, input }) => {
|
||||
await assertCanReadResource(
|
||||
ctx,
|
||||
input.resourceId,
|
||||
"You can only view chargeability details for your own resource unless you have staff access",
|
||||
);
|
||||
|
||||
const [year, month] = input.month.split("-").map(Number) as [number, number];
|
||||
const { start: monthStart, end: monthEnd } = getMonthRange(year, month);
|
||||
|
||||
const resource = await ctx.db.resource.findUniqueOrThrow({
|
||||
where: { id: input.resourceId },
|
||||
select: {
|
||||
id: true,
|
||||
displayName: true,
|
||||
eid: true,
|
||||
fte: true,
|
||||
lcrCents: true,
|
||||
chargeabilityTarget: true,
|
||||
countryId: true,
|
||||
federalState: true,
|
||||
metroCityId: true,
|
||||
availability: true,
|
||||
country: { select: { id: true, code: true, name: true, dailyWorkingHours: true, scheduleRules: true } },
|
||||
metroCity: { select: { id: true, name: true } },
|
||||
managementLevelGroup: { select: { id: true, name: true, targetPercentage: true } },
|
||||
},
|
||||
});
|
||||
|
||||
const dailyHours = resource.country?.dailyWorkingHours ?? 8;
|
||||
const scheduleRules = resource.country?.scheduleRules as SpainScheduleRule | null;
|
||||
const targetRatio = resource.managementLevelGroup?.targetPercentage ?? (resource.chargeabilityTarget / 100);
|
||||
|
||||
const availability = resource.availability as WeekdayAvailability | null;
|
||||
const weeklyAvailability: WeekdayAvailability = availability ?? {
|
||||
monday: dailyHours,
|
||||
tuesday: dailyHours,
|
||||
wednesday: dailyHours,
|
||||
thursday: dailyHours,
|
||||
friday: dailyHours,
|
||||
saturday: 0,
|
||||
sunday: 0,
|
||||
};
|
||||
|
||||
const assignments = await ctx.db.assignment.findMany({
|
||||
where: {
|
||||
resourceId: input.resourceId,
|
||||
startDate: { lte: monthEnd },
|
||||
endDate: { gte: monthStart },
|
||||
status: { in: ["CONFIRMED", "ACTIVE", "PROPOSED"] },
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
hoursPerDay: true,
|
||||
startDate: true,
|
||||
endDate: true,
|
||||
dailyCostCents: true,
|
||||
status: true,
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
shortCode: true,
|
||||
orderType: true,
|
||||
utilizationCategory: { select: { code: true } },
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const vacations = await ctx.db.vacation.findMany({
|
||||
where: {
|
||||
resourceId: input.resourceId,
|
||||
status: VacationStatus.APPROVED,
|
||||
startDate: { lte: monthEnd },
|
||||
endDate: { gte: monthStart },
|
||||
},
|
||||
select: { startDate: true, endDate: true, type: true, isHalfDay: true },
|
||||
});
|
||||
|
||||
const resolvedHolidays = await getResolvedCalendarHolidays(asHolidayResolverDb(ctx.db), {
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
countryId: resource.countryId,
|
||||
countryCode: resource.country?.code,
|
||||
federalState: resource.federalState,
|
||||
metroCityId: resource.metroCityId,
|
||||
metroCityName: resource.metroCity?.name,
|
||||
});
|
||||
const holidayAvailability = collectHolidayAvailability({
|
||||
vacations,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
countryCode: resource.country?.code,
|
||||
federalState: resource.federalState,
|
||||
metroCityName: resource.metroCity?.name,
|
||||
resolvedHolidayStrings: resolvedHolidays.map((holiday) => holiday.date),
|
||||
});
|
||||
const absenceDays = holidayAvailability.absenceDays;
|
||||
|
||||
const contexts = await loadResourceDailyAvailabilityContexts(
|
||||
ctx.db,
|
||||
[{
|
||||
id: resource.id,
|
||||
availability: weeklyAvailability,
|
||||
countryId: resource.countryId,
|
||||
countryCode: resource.country?.code,
|
||||
federalState: resource.federalState,
|
||||
metroCityId: resource.metroCityId,
|
||||
metroCityName: resource.metroCity?.name,
|
||||
}],
|
||||
monthStart,
|
||||
monthEnd,
|
||||
);
|
||||
const availabilityContext = contexts.get(resource.id);
|
||||
|
||||
let calcRules: CalculationRule[] = DEFAULT_CALCULATION_RULES;
|
||||
try {
|
||||
const dbRules = await ctx.db.calculationRule.findMany({
|
||||
where: { isActive: true },
|
||||
orderBy: [{ priority: "desc" }],
|
||||
});
|
||||
if (dbRules.length > 0) {
|
||||
calcRules = dbRules as unknown as CalculationRule[];
|
||||
}
|
||||
} catch {
|
||||
// table may not exist yet
|
||||
}
|
||||
|
||||
const baseWorkingDays = countEffectiveWorkingDays({
|
||||
availability: weeklyAvailability,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
context: undefined,
|
||||
});
|
||||
const effectiveWorkingDays = countEffectiveWorkingDays({
|
||||
availability: weeklyAvailability,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
context: availabilityContext,
|
||||
});
|
||||
const baseAvailableHours = calculateEffectiveAvailableHours({
|
||||
availability: weeklyAvailability,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
context: undefined,
|
||||
});
|
||||
const effectiveAvailableHours = calculateEffectiveAvailableHours({
|
||||
availability: weeklyAvailability,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
context: availabilityContext,
|
||||
});
|
||||
|
||||
const publicHolidayDates = resolvedHolidays.map((holiday) => new Date(`${holiday.date}T00:00:00.000Z`));
|
||||
const publicHolidayWorkdayCount = publicHolidayDates.reduce((count, date) => (
|
||||
count + (getAvailabilityHoursForDate(weeklyAvailability, date) > 0 ? 1 : 0)
|
||||
), 0);
|
||||
const publicHolidayHoursDeduction = sumAvailabilityHoursForDates(
|
||||
weeklyAvailability,
|
||||
publicHolidayDates,
|
||||
);
|
||||
const absenceDayEquivalent = absenceDays.reduce((sum, absence) => {
|
||||
if (absence.type === "PUBLIC_HOLIDAY") {
|
||||
return sum;
|
||||
}
|
||||
return sum + (absence.isHalfDay ? 0.5 : 1);
|
||||
}, 0);
|
||||
const absenceHoursDeduction = absenceDays.reduce((sum, absence) => {
|
||||
if (absence.type === "PUBLIC_HOLIDAY") {
|
||||
return sum;
|
||||
}
|
||||
const baseHours = getAvailabilityHoursForDate(weeklyAvailability, absence.date);
|
||||
return sum + baseHours * (absence.isHalfDay ? 0.5 : 1);
|
||||
}, 0);
|
||||
|
||||
const slices: AssignmentSlice[] = [];
|
||||
const assignmentBreakdown: Array<{
|
||||
project: string;
|
||||
code: string;
|
||||
hours: number;
|
||||
status: string;
|
||||
}> = [];
|
||||
let totalBookedHours = 0;
|
||||
|
||||
for (const assignment of assignments) {
|
||||
const overlapStart = new Date(Math.max(monthStart.getTime(), assignment.startDate.getTime()));
|
||||
const overlapEnd = new Date(Math.min(monthEnd.getTime(), assignment.endDate.getTime()));
|
||||
const categoryCode = assignment.project.utilizationCategory?.code ?? "Chg";
|
||||
|
||||
const calcResult = calculateAllocation({
|
||||
lcrCents: resource.lcrCents,
|
||||
hoursPerDay: assignment.hoursPerDay,
|
||||
startDate: overlapStart,
|
||||
endDate: overlapEnd,
|
||||
availability: weeklyAvailability,
|
||||
absenceDays,
|
||||
calculationRules: calcRules,
|
||||
orderType: assignment.project.orderType,
|
||||
projectId: assignment.project.id,
|
||||
});
|
||||
if (calcResult.workingDays <= 0 && calcResult.totalHours <= 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
totalBookedHours += calcResult.totalHours;
|
||||
assignmentBreakdown.push({
|
||||
project: assignment.project.name,
|
||||
code: assignment.project.shortCode,
|
||||
hours: round1(calcResult.totalHours),
|
||||
status: assignment.status,
|
||||
});
|
||||
slices.push({
|
||||
hoursPerDay: assignment.hoursPerDay,
|
||||
workingDays: calcResult.workingDays,
|
||||
categoryCode,
|
||||
...(calcResult.totalChargeableHours !== undefined
|
||||
? { totalChargeableHours: calcResult.totalChargeableHours }
|
||||
: {}),
|
||||
});
|
||||
}
|
||||
|
||||
const forecast = deriveResourceForecast({
|
||||
fte: resource.fte,
|
||||
targetPercentage: targetRatio,
|
||||
assignments: slices,
|
||||
sah: effectiveAvailableHours,
|
||||
});
|
||||
|
||||
const formattedHolidays = resolvedHolidays.map((holiday) => formatResolvedHolidaySummary({
|
||||
...holiday,
|
||||
calendarName: holiday.calendarName ?? "Built-in",
|
||||
sourceType: holiday.sourceType ?? "system",
|
||||
}));
|
||||
const workingDays = round1(effectiveWorkingDays);
|
||||
const baseWorkingDaysRounded = round1(baseWorkingDays);
|
||||
const baseAvailableHoursRounded = round1(baseAvailableHours);
|
||||
const availableHours = round1(effectiveAvailableHours);
|
||||
const bookedHours = round1(totalBookedHours);
|
||||
const targetPct = round1(targetRatio * 100);
|
||||
const targetHours = availableHours > 0 ? round1((availableHours * targetPct) / 100) : 0;
|
||||
const chargeabilityPct = round1(forecast.chg * 100);
|
||||
const unassignedHours = round1(Math.max(0, availableHours - bookedHours));
|
||||
|
||||
return {
|
||||
resource: resource.displayName,
|
||||
eid: resource.eid,
|
||||
month: input.month,
|
||||
periodStart: monthStart.toISOString().slice(0, 10),
|
||||
periodEnd: monthEnd.toISOString().slice(0, 10),
|
||||
fte: round1(resource.fte),
|
||||
target: `${targetPct}%`,
|
||||
targetPct,
|
||||
targetHours,
|
||||
workingDays,
|
||||
baseWorkingDays: baseWorkingDaysRounded,
|
||||
locationContext: {
|
||||
countryCode: resource.country?.code ?? null,
|
||||
country: resource.country?.name ?? resource.country?.code ?? null,
|
||||
federalState: resource.federalState ?? null,
|
||||
metroCity: resource.metroCity?.name ?? null,
|
||||
},
|
||||
baseAvailableHours: baseAvailableHoursRounded,
|
||||
availableHours,
|
||||
bookedHours,
|
||||
unassignedHours,
|
||||
chargeability: `${chargeabilityPct}%`,
|
||||
chargeabilityPct,
|
||||
onTarget: chargeabilityPct >= targetPct,
|
||||
holidaySummary: {
|
||||
count: formattedHolidays.length,
|
||||
workdayCount: round1(publicHolidayWorkdayCount),
|
||||
hoursDeduction: round1(publicHolidayHoursDeduction),
|
||||
holidays: formattedHolidays,
|
||||
breakdown: summarizeResolvedHolidaySummary(formattedHolidays),
|
||||
},
|
||||
absenceSummary: {
|
||||
dayEquivalent: round1(absenceDayEquivalent),
|
||||
hoursDeduction: round1(absenceHoursDeduction),
|
||||
},
|
||||
capacityBreakdown: {
|
||||
formula: "baseAvailableHours - holidayHoursDeduction - absenceHoursDeduction = availableHours",
|
||||
baseAvailableHours: baseAvailableHoursRounded,
|
||||
holidayHoursDeduction: round1(publicHolidayHoursDeduction),
|
||||
absenceHoursDeduction: round1(absenceHoursDeduction),
|
||||
availableHours,
|
||||
},
|
||||
averages: {
|
||||
availableHoursPerWorkingDay: averagePerWorkingDay(availableHours, workingDays),
|
||||
bookedHoursPerWorkingDay: averagePerWorkingDay(bookedHours, workingDays),
|
||||
remainingHoursPerWorkingDay: averagePerWorkingDay(Math.max(0, availableHours - bookedHours), workingDays),
|
||||
},
|
||||
allocations: assignmentBreakdown,
|
||||
scheduleContext: {
|
||||
dailyWorkingHours: dailyHours,
|
||||
hasScheduleRules: Boolean(scheduleRules),
|
||||
},
|
||||
};
|
||||
}),
|
||||
|
||||
listSummaries: resourceOverviewProcedure
|
||||
.input(z.object({
|
||||
search: z.string().optional(),
|
||||
country: z.string().optional(),
|
||||
metroCity: z.string().optional(),
|
||||
orgUnit: z.string().optional(),
|
||||
roleName: z.string().optional(),
|
||||
isActive: z.boolean().optional().default(true),
|
||||
limit: z.number().int().min(1).max(100).default(50),
|
||||
}))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const resources = await readResourceSummariesSnapshot(ctx, {
|
||||
isActive: input.isActive,
|
||||
limit: input.limit,
|
||||
...(input.search ? { search: input.search } : {}),
|
||||
...(input.country ? { country: input.country } : {}),
|
||||
...(input.metroCity ? { metroCity: input.metroCity } : {}),
|
||||
...(input.orgUnit ? { orgUnit: input.orgUnit } : {}),
|
||||
...(input.roleName ? { roleName: input.roleName } : {}),
|
||||
});
|
||||
return resources.map(mapResourceSummary);
|
||||
}),
|
||||
|
||||
listSummariesDetail: resourceOverviewProcedure
|
||||
.input(z.object({
|
||||
search: z.string().optional(),
|
||||
country: z.string().optional(),
|
||||
metroCity: z.string().optional(),
|
||||
orgUnit: z.string().optional(),
|
||||
roleName: z.string().optional(),
|
||||
isActive: z.boolean().optional().default(true),
|
||||
limit: z.number().int().min(1).max(100).default(50),
|
||||
}))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const resources = await readResourceSummaryDetailsSnapshot(ctx, {
|
||||
isActive: input.isActive,
|
||||
limit: input.limit,
|
||||
...(input.search ? { search: input.search } : {}),
|
||||
...(input.country ? { country: input.country } : {}),
|
||||
...(input.metroCity ? { metroCity: input.metroCity } : {}),
|
||||
...(input.orgUnit ? { orgUnit: input.orgUnit } : {}),
|
||||
...(input.roleName ? { roleName: input.roleName } : {}),
|
||||
});
|
||||
return resources.map(mapResourceSummaryDetail);
|
||||
}),
|
||||
|
||||
directory: protectedProcedure
|
||||
.input(ResourceDirectoryQuerySchema)
|
||||
.query(async ({ ctx, input }) => {
|
||||
const {
|
||||
chapter,
|
||||
chapters,
|
||||
isActive,
|
||||
search,
|
||||
eids,
|
||||
countryIds,
|
||||
excludedCountryIds,
|
||||
includeWithoutCountry,
|
||||
resourceTypes,
|
||||
excludedResourceTypes,
|
||||
includeWithoutResourceType,
|
||||
rolledOff,
|
||||
departed,
|
||||
page,
|
||||
limit,
|
||||
cursor,
|
||||
} = input;
|
||||
|
||||
const resources = await listStaffResources(ctx, {
|
||||
chapter,
|
||||
chapters,
|
||||
isActive,
|
||||
search,
|
||||
eids,
|
||||
countryIds,
|
||||
excludedCountryIds,
|
||||
includeWithoutCountry,
|
||||
resourceTypes,
|
||||
excludedResourceTypes,
|
||||
includeWithoutResourceType,
|
||||
rolledOff,
|
||||
departed,
|
||||
page,
|
||||
limit,
|
||||
cursor,
|
||||
includeRoles: false,
|
||||
});
|
||||
|
||||
return {
|
||||
...resources,
|
||||
resources: resources.resources.map((resource) => ({
|
||||
id: resource.id,
|
||||
eid: resource.eid,
|
||||
displayName: resource.displayName,
|
||||
chapter: resource.chapter,
|
||||
isActive: resource.isActive,
|
||||
})),
|
||||
};
|
||||
}),
|
||||
|
||||
listStaff: resourceOverviewProcedure
|
||||
.input(ResourceListQuerySchema)
|
||||
.query(async ({ ctx, input }) => listStaffResources(ctx, input)),
|
||||
|
||||
chapters: protectedProcedure.query(async ({ ctx }) => {
|
||||
const resources = await ctx.db.resource.findMany({
|
||||
where: { isActive: true, chapter: { not: null } },
|
||||
select: { chapter: true },
|
||||
distinct: ["chapter"],
|
||||
orderBy: { chapter: "asc" },
|
||||
});
|
||||
return resources.map((resource) => resource.chapter as string);
|
||||
}),
|
||||
};
|
||||
Reference in New Issue
Block a user