chore(repo): initialize planarchy workspace

2026-03-14 14:31:09 +01:00
commit dd55d0e78b
769 changed files with 166461 additions and 0 deletions
@@ -0,0 +1,245 @@
+import {
+  deriveResourceForecast,
+  calculateGroupChargeability,
+  calculateGroupTarget,
+  sumFte,
+  getMonthRange,
+  getMonthKeys,
+  countWorkingDaysInOverlap,
+  calculateSAH,
+  type AssignmentSlice,
+} from "@planarchy/engine";
+import type { SpainScheduleRule } from "@planarchy/shared";
+import { listAssignmentBookings } from "@planarchy/application";
+import { VacationStatus } from "@planarchy/db";
+import { z } from "zod";
+import { createTRPCRouter, controllerProcedure } from "../trpc.js";
+
+export const chargeabilityReportRouter = createTRPCRouter({
+  getReport: controllerProcedure
+    .input(
+      z.object({
+        startMonth: z.string().regex(/^\d{4}-\d{2}$/), // "2026-01"
+        endMonth: z.string().regex(/^\d{4}-\d{2}$/),
+        orgUnitId: z.string().optional(),
+        managementLevelGroupId: z.string().optional(),
+        countryId: z.string().optional(),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      const { startMonth, endMonth } = input;
+
+      // Parse month range
+      const [startYear, startMo] = startMonth.split("-").map(Number) as [number, number];
+      const [endYear, endMo] = endMonth.split("-").map(Number) as [number, number];
+      const rangeStart = getMonthRange(startYear, startMo).start;
+      const rangeEnd = getMonthRange(endYear, endMo).end;
+      const monthKeys = getMonthKeys(rangeStart, rangeEnd);
+
+      // Fetch resources with filters
+      const resourceWhere = {
+        isActive: true,
+        chgResponsibility: true,
+        departed: false,
+        rolledOff: false,
+        ...(input.orgUnitId ? { orgUnitId: input.orgUnitId } : {}),
+        ...(input.managementLevelGroupId ? { managementLevelGroupId: input.managementLevelGroupId } : {}),
+        ...(input.countryId ? { countryId: input.countryId } : {}),
+      };
+
+      const resources = await ctx.db.resource.findMany({
+        where: resourceWhere,
+        select: {
+          id: true,
+          eid: true,
+          displayName: true,
+          fte: true,
+          chargeabilityTarget: true,
+          country: { select: { id: true, code: true, dailyWorkingHours: true, scheduleRules: true } },
+          orgUnit: { select: { id: true, name: true } },
+          managementLevelGroup: { select: { id: true, name: true, targetPercentage: true } },
+          managementLevel: { select: { id: true, name: true } },
+          metroCity: { select: { id: true, name: true } },
+        },
+        orderBy: { displayName: "asc" },
+      });
+
+      if (resources.length === 0) {
+        return {
+          monthKeys,
+          resources: [],
+          groupTotals: monthKeys.map((key) => ({
+            monthKey: key,
+            totalFte: 0,
+            chg: 0,
+            target: 0,
+            gap: 0,
+          })),
+        };
+      }
+
+      // Fetch all bookings (assignments + legacy allocations) in the date range
+      const resourceIds = resources.map((r) => r.id);
+      const allBookings = await listAssignmentBookings(ctx.db, {
+        startDate: rangeStart,
+        endDate: rangeEnd,
+        resourceIds,
+      });
+
+      // Enrich with utilization category — fetch project util categories in bulk
+      const projectIds = [...new Set(allBookings.map((b) => b.projectId))];
+      const projectUtilCats = projectIds.length > 0
+        ? await ctx.db.project.findMany({
+            where: { id: { in: projectIds } },
+            select: { id: true, utilizationCategory: { select: { code: true } } },
+          })
+        : [];
+      const projectUtilCatMap = new Map(
+        projectUtilCats.map((p) => [p.id, p.utilizationCategory?.code ?? null]),
+      );
+
+      // Normalize bookings to a common shape
+      const assignments = allBookings
+        .filter((b) => b.resourceId !== null)
+        .map((b) => ({
+          resourceId: b.resourceId!,
+          startDate: b.startDate,
+          endDate: b.endDate,
+          hoursPerDay: b.hoursPerDay,
+          project: {
+            status: b.project.status,
+            utilizationCategory: { code: projectUtilCatMap.get(b.projectId) ?? null },
+          },
+        }));
+
+      // Fetch vacations/absences in the range
+      const vacations = await ctx.db.vacation.findMany({
+        where: {
+          resourceId: { in: resourceIds },
+          status: VacationStatus.APPROVED,
+          startDate: { lte: rangeEnd },
+          endDate: { gte: rangeStart },
+        },
+        select: {
+          resourceId: true,
+          startDate: true,
+          endDate: true,
+        },
+      });
+
+      // Build per-resource, per-month forecasts
+      const resourceRows = resources.map((resource) => {
+        const resourceAssignments = assignments.filter((a) => a.resourceId === resource.id);
+        const resourceVacations = vacations.filter((v) => v.resourceId === resource.id);
+        // Prefer mgmt level group target; fall back to legacy chargeabilityTarget (0-100 → 0-1)
+        const targetPct = resource.managementLevelGroup?.targetPercentage
+          ?? (resource.chargeabilityTarget / 100);
+        const dailyHours = resource.country?.dailyWorkingHours ?? 8;
+        const scheduleRules = resource.country?.scheduleRules as SpainScheduleRule | null;
+
+        const months = monthKeys.map((key) => {
+          const [y, m] = key.split("-").map(Number) as [number, number];
+          const { start: monthStart, end: monthEnd } = getMonthRange(y, m);
+
+          // Compute absence days for SAH
+          const absenceDates: string[] = [];
+          for (const v of resourceVacations) {
+            const vStart = new Date(Math.max(v.startDate.getTime(), monthStart.getTime()));
+            const vEnd = new Date(Math.min(v.endDate.getTime(), monthEnd.getTime()));
+            if (vStart > vEnd) continue;
+            const cursor = new Date(vStart);
+            cursor.setUTCHours(0, 0, 0, 0);
+            const endNorm = new Date(vEnd);
+            endNorm.setUTCHours(0, 0, 0, 0);
+            while (cursor <= endNorm) {
+              absenceDates.push(cursor.toISOString().slice(0, 10));
+              cursor.setUTCDate(cursor.getUTCDate() + 1);
+            }
+          }
+
+          // Calculate SAH for this resource+month
+          const sahResult = calculateSAH({
+            dailyWorkingHours: dailyHours,
+            scheduleRules,
+            fte: resource.fte,
+            periodStart: monthStart,
+            periodEnd: monthEnd,
+            publicHolidays: [], // TODO: integrate public holidays from country
+            absenceDays: absenceDates,
+          });
+
+          // Build assignment slices for this month
+          const slices: AssignmentSlice[] = [];
+          for (const a of resourceAssignments) {
+            // Skip DRAFT projects
+            if (a.project.status === "DRAFT" || a.project.status === "CANCELLED") continue;
+            const workingDays = countWorkingDaysInOverlap(monthStart, monthEnd, a.startDate, a.endDate);
+            if (workingDays <= 0) continue;
+
+            const categoryCode = a.project.utilizationCategory?.code ?? "Chg";
+            slices.push({
+              hoursPerDay: a.hoursPerDay,
+              workingDays,
+              categoryCode,
+            });
+          }
+
+          const forecast = deriveResourceForecast({
+            fte: resource.fte,
+            targetPercentage: targetPct,
+            assignments: slices,
+            sah: sahResult.standardAvailableHours,
+          });
+
+          return {
+            monthKey: key,
+            sah: sahResult.standardAvailableHours,
+            ...forecast,
+          };
+        });
+
+        return {
+          id: resource.id,
+          eid: resource.eid,
+          displayName: resource.displayName,
+          fte: resource.fte,
+          country: resource.country?.code ?? null,
+          city: resource.metroCity?.name ?? null,
+          orgUnit: resource.orgUnit?.name ?? null,
+          mgmtGroup: resource.managementLevelGroup?.name ?? null,
+          mgmtLevel: resource.managementLevel?.name ?? null,
+          targetPct,
+          months,
+        };
+      });
+
+      // Compute group totals per month
+      const groupTotals = monthKeys.map((key, monthIdx) => {
+        const groupInputs = resourceRows.map((r) => ({
+          fte: r.fte,
+          chargeability: r.months[monthIdx]!.chg,
+        }));
+        const targetInputs = resourceRows.map((r) => ({
+          fte: r.fte,
+          targetPercentage: r.targetPct,
+        }));
+
+        const chg = calculateGroupChargeability(groupInputs);
+        const target = calculateGroupTarget(targetInputs);
+
+        return {
+          monthKey: key,
+          totalFte: sumFte(resourceRows),
+          chg,
+          target,
+          gap: chg - target,
+        };
+      });
+
+      return {
+        monthKeys,
+        resources: resourceRows,
+        groupTotals,
+      };
+    }),
+});