1366 lines
44 KiB
TypeScript
1366 lines
44 KiB
TypeScript
import {
|
|
buildSplitAllocationReadModel,
|
|
createAssignment,
|
|
createDemandRequirement,
|
|
deleteAssignment,
|
|
deleteAllocationEntry,
|
|
deleteDemandRequirement,
|
|
fillDemandRequirement,
|
|
fillOpenDemand,
|
|
loadAllocationEntry,
|
|
updateAllocationEntry,
|
|
updateAssignment,
|
|
updateDemandRequirement,
|
|
} from "@capakraken/application";
|
|
import {
|
|
AllocationStatus,
|
|
buildTaskAction,
|
|
CreateAllocationSchema,
|
|
CreateAssignmentSchema,
|
|
CreateDemandRequirementSchema,
|
|
FillDemandRequirementSchema,
|
|
FillOpenDemandByAllocationSchema,
|
|
PermissionKey,
|
|
type WeekdayAvailability,
|
|
UpdateAssignmentSchema,
|
|
UpdateAllocationSchema,
|
|
UpdateDemandRequirementSchema,
|
|
} from "@capakraken/shared";
|
|
import { TRPCError } from "@trpc/server";
|
|
import { z } from "zod";
|
|
import { findUniqueOrThrow } from "../db/helpers.js";
|
|
import { anonymizeResource, getAnonymizationDirectory } from "../lib/anonymization.js";
|
|
import { checkBudgetThresholds } from "../lib/budget-alerts.js";
|
|
import { dispatchWebhooks } from "../lib/webhook-dispatcher.js";
|
|
import { emitAllocationCreated, emitAllocationDeleted, emitAllocationUpdated, emitNotificationCreated } from "../sse/event-bus.js";
|
|
import { generateAutoSuggestions } from "../lib/auto-staffing.js";
|
|
import { invalidateDashboardCache } from "../lib/cache.js";
|
|
import { logger } from "../lib/logger.js";
|
|
import {
|
|
calculateEffectiveAvailableHours,
|
|
calculateEffectiveBookedHours,
|
|
calculateEffectiveDayAvailability,
|
|
countEffectiveWorkingDays,
|
|
loadResourceDailyAvailabilityContexts,
|
|
} from "../lib/resource-capacity.js";
|
|
import { createTRPCRouter, managerProcedure, planningReadProcedure, requirePermission } from "../trpc.js";
|
|
import { PROJECT_BRIEF_SELECT, RESOURCE_BRIEF_SELECT, ROLE_BRIEF_SELECT } from "../db/selects.js";
|
|
|
|
const DEMAND_INCLUDE = {
|
|
project: { select: PROJECT_BRIEF_SELECT },
|
|
roleEntity: { select: ROLE_BRIEF_SELECT },
|
|
assignments: {
|
|
include: {
|
|
resource: { select: RESOURCE_BRIEF_SELECT },
|
|
project: { select: PROJECT_BRIEF_SELECT },
|
|
roleEntity: { select: ROLE_BRIEF_SELECT },
|
|
},
|
|
},
|
|
} as const;
|
|
|
|
const ASSIGNMENT_INCLUDE = {
|
|
resource: { select: RESOURCE_BRIEF_SELECT },
|
|
project: { select: PROJECT_BRIEF_SELECT },
|
|
roleEntity: { select: ROLE_BRIEF_SELECT },
|
|
demandRequirement: {
|
|
select: {
|
|
id: true,
|
|
projectId: true,
|
|
startDate: true,
|
|
endDate: true,
|
|
hoursPerDay: true,
|
|
percentage: true,
|
|
role: true,
|
|
roleId: true,
|
|
headcount: true,
|
|
status: true,
|
|
},
|
|
},
|
|
} as const;
|
|
|
|
type AllocationListFilters = {
|
|
projectId?: string | undefined;
|
|
resourceId?: string | undefined;
|
|
status?: AllocationStatus | undefined;
|
|
};
|
|
|
|
type AllocationEntryUpdateInput = z.infer<typeof UpdateAllocationSchema>;
|
|
|
|
type AssignmentResolutionInput = {
|
|
assignmentId?: string | undefined;
|
|
resourceId?: string | undefined;
|
|
projectId?: string | undefined;
|
|
startDate?: Date | undefined;
|
|
endDate?: Date | undefined;
|
|
selectionMode?: "WINDOW" | "EXACT_START" | undefined;
|
|
excludeCancelled?: boolean | undefined;
|
|
};
|
|
|
|
type CreateDemandDraftInput = {
|
|
projectId: string;
|
|
role?: string | undefined;
|
|
roleId?: string | undefined;
|
|
headcount?: number | undefined;
|
|
hoursPerDay: number;
|
|
startDate: Date;
|
|
endDate: Date;
|
|
budgetCents?: number | undefined;
|
|
metadata?: Record<string, unknown> | undefined;
|
|
};
|
|
|
|
function runAllocationBackgroundEffect(
|
|
effectName: string,
|
|
execute: () => unknown,
|
|
metadata: Record<string, unknown> = {},
|
|
): void {
|
|
void Promise.resolve()
|
|
.then(execute)
|
|
.catch((error) => {
|
|
logger.error(
|
|
{ err: error, effectName, ...metadata },
|
|
"Allocation background side effect failed",
|
|
);
|
|
});
|
|
}
|
|
|
|
function invalidateDashboardCacheInBackground(): void {
|
|
runAllocationBackgroundEffect("invalidateDashboardCache", () => invalidateDashboardCache());
|
|
}
|
|
|
|
function checkBudgetThresholdsInBackground(
|
|
db: import("@capakraken/db").PrismaClient,
|
|
projectId: string,
|
|
): void {
|
|
runAllocationBackgroundEffect(
|
|
"checkBudgetThresholds",
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
() => checkBudgetThresholds(db as any, projectId),
|
|
{ projectId },
|
|
);
|
|
}
|
|
|
|
function dispatchAllocationWebhookInBackground(
|
|
db: import("@capakraken/db").PrismaClient,
|
|
event: string,
|
|
payload: Record<string, unknown>,
|
|
): void {
|
|
runAllocationBackgroundEffect(
|
|
"dispatchWebhooks",
|
|
() => dispatchWebhooks(db, event, payload),
|
|
{ event },
|
|
);
|
|
}
|
|
|
|
function generateAutoSuggestionsInBackground(
|
|
db: import("@capakraken/db").PrismaClient,
|
|
demandRequirementId: string,
|
|
): void {
|
|
runAllocationBackgroundEffect(
|
|
"generateAutoSuggestions",
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
() => generateAutoSuggestions(db as any, demandRequirementId),
|
|
{ demandRequirementId },
|
|
);
|
|
}
|
|
|
|
function toDemandRequirementUpdateInput(input: AllocationEntryUpdateInput) {
|
|
return {
|
|
...(input.projectId !== undefined ? { projectId: input.projectId } : {}),
|
|
...(input.startDate !== undefined ? { startDate: input.startDate } : {}),
|
|
...(input.endDate !== undefined ? { endDate: input.endDate } : {}),
|
|
...(input.hoursPerDay !== undefined ? { hoursPerDay: input.hoursPerDay } : {}),
|
|
...(input.percentage !== undefined ? { percentage: input.percentage } : {}),
|
|
...(input.role !== undefined ? { role: input.role } : {}),
|
|
...(input.roleId !== undefined ? { roleId: input.roleId } : {}),
|
|
...(input.headcount !== undefined ? { headcount: input.headcount } : {}),
|
|
...(input.budgetCents !== undefined ? { budgetCents: input.budgetCents } : {}),
|
|
...(input.status !== undefined ? { status: input.status } : {}),
|
|
...(input.metadata !== undefined ? { metadata: input.metadata } : {}),
|
|
};
|
|
}
|
|
|
|
function toAssignmentUpdateInput(input: AllocationEntryUpdateInput) {
|
|
return {
|
|
...(input.resourceId !== undefined ? { resourceId: input.resourceId } : {}),
|
|
...(input.projectId !== undefined ? { projectId: input.projectId } : {}),
|
|
...(input.startDate !== undefined ? { startDate: input.startDate } : {}),
|
|
...(input.endDate !== undefined ? { endDate: input.endDate } : {}),
|
|
...(input.hoursPerDay !== undefined ? { hoursPerDay: input.hoursPerDay } : {}),
|
|
...(input.percentage !== undefined ? { percentage: input.percentage } : {}),
|
|
...(input.role !== undefined ? { role: input.role } : {}),
|
|
...(input.roleId !== undefined ? { roleId: input.roleId } : {}),
|
|
...(input.status !== undefined ? { status: input.status } : {}),
|
|
...(input.metadata !== undefined ? { metadata: input.metadata } : {}),
|
|
};
|
|
}
|
|
|
|
async function loadAllocationReadModel(
|
|
db: Pick<import("@capakraken/db").PrismaClient, "demandRequirement" | "assignment" | "systemSettings" | "resource">,
|
|
input: AllocationListFilters,
|
|
) {
|
|
const [demandRequirements, assignments] = await Promise.all([
|
|
input.resourceId
|
|
? Promise.resolve([])
|
|
: db.demandRequirement.findMany({
|
|
where: {
|
|
...(input.projectId ? { projectId: input.projectId } : {}),
|
|
...(input.status ? { status: input.status } : {}),
|
|
},
|
|
include: DEMAND_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
}),
|
|
db.assignment.findMany({
|
|
where: {
|
|
...(input.projectId ? { projectId: input.projectId } : {}),
|
|
...(input.resourceId ? { resourceId: input.resourceId } : {}),
|
|
...(input.status ? { status: input.status } : {}),
|
|
},
|
|
include: ASSIGNMENT_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
}),
|
|
]);
|
|
|
|
const readModel = buildSplitAllocationReadModel({ demandRequirements, assignments });
|
|
|
|
const directory = await getAnonymizationDirectory(db as import("@capakraken/db").PrismaClient);
|
|
if (!directory) return readModel;
|
|
|
|
function anonymizeAllocation<T extends { resource?: { id: string; eid?: string | null; displayName?: string | null; email?: string | null } | null }>(alloc: T): T {
|
|
if (!alloc.resource) return alloc;
|
|
return { ...alloc, resource: anonymizeResource(alloc.resource, directory) };
|
|
}
|
|
|
|
return {
|
|
...readModel,
|
|
allocations: readModel.allocations.map(anonymizeAllocation),
|
|
demands: readModel.demands.map(anonymizeAllocation),
|
|
assignments: readModel.assignments.map(anonymizeAllocation),
|
|
};
|
|
}
|
|
|
|
async function findAllocationEntryOrNull(
|
|
db: Pick<import("@capakraken/db").PrismaClient, "demandRequirement" | "assignment">,
|
|
id: string,
|
|
) {
|
|
try {
|
|
return await loadAllocationEntry(db, id);
|
|
} catch (error) {
|
|
if (error instanceof TRPCError && error.code === "NOT_FOUND") {
|
|
return null;
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function toIsoDate(value: Date) {
|
|
return value.toISOString().slice(0, 10);
|
|
}
|
|
|
|
function round1(value: number) {
|
|
return Math.round(value * 10) / 10;
|
|
}
|
|
|
|
function averagePerWorkingDay(totalHours: number, workingDays: number) {
|
|
if (workingDays <= 0) {
|
|
return 0;
|
|
}
|
|
return round1(totalHours / workingDays);
|
|
}
|
|
|
|
function buildCreateDemandRequirementInput(input: CreateDemandDraftInput): z.infer<typeof CreateDemandRequirementSchema> {
|
|
return {
|
|
projectId: input.projectId,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
hoursPerDay: input.hoursPerDay,
|
|
percentage: (input.hoursPerDay / 8) * 100,
|
|
status: AllocationStatus.PROPOSED,
|
|
headcount: input.headcount ?? 1,
|
|
budgetCents: input.budgetCents ?? 0,
|
|
metadata: input.metadata ?? {},
|
|
...(input.role ? { role: input.role } : {}),
|
|
...(input.roleId ? { roleId: input.roleId } : {}),
|
|
};
|
|
}
|
|
|
|
async function getDemandRequirementByIdOrThrow(
|
|
db: Pick<import("@capakraken/db").PrismaClient, "demandRequirement">,
|
|
id: string,
|
|
) {
|
|
return findUniqueOrThrow(
|
|
db.demandRequirement.findUnique({
|
|
where: { id },
|
|
include: DEMAND_INCLUDE,
|
|
}),
|
|
"Demand requirement",
|
|
);
|
|
}
|
|
|
|
async function createDemandRequirementWithEffects(
|
|
db: import("@capakraken/db").PrismaClient,
|
|
input: z.infer<typeof CreateDemandRequirementSchema>,
|
|
) {
|
|
const demandRequirement = await db.$transaction(async (tx) => {
|
|
return createDemandRequirement(
|
|
tx as unknown as Parameters<typeof createDemandRequirement>[0],
|
|
input,
|
|
);
|
|
});
|
|
|
|
emitAllocationCreated({
|
|
id: demandRequirement.id,
|
|
projectId: demandRequirement.projectId,
|
|
resourceId: null,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
|
|
const [project, roleEntity, managers] = await Promise.all([
|
|
db.project.findUnique({
|
|
where: { id: demandRequirement.projectId },
|
|
select: { name: true },
|
|
}),
|
|
demandRequirement.roleId
|
|
? db.role.findUnique({
|
|
where: { id: demandRequirement.roleId },
|
|
select: { name: true },
|
|
})
|
|
: Promise.resolve(null),
|
|
db.user.findMany({
|
|
where: { systemRole: { in: ["ADMIN", "MANAGER"] } },
|
|
select: { id: true },
|
|
}),
|
|
]);
|
|
const roleName = roleEntity?.name ?? demandRequirement.role ?? "Unspecified role";
|
|
const projectName = project?.name ?? "Unknown project";
|
|
const headcount = demandRequirement.headcount ?? 1;
|
|
|
|
for (const manager of managers) {
|
|
const task = await db.notification.create({
|
|
data: {
|
|
userId: manager.id,
|
|
category: "TASK",
|
|
type: "DEMAND_FILL",
|
|
priority: "NORMAL",
|
|
title: `Staff demand: ${roleName} for ${projectName}`,
|
|
body: `${headcount} ${roleName} needed for project ${projectName}`,
|
|
taskStatus: "OPEN",
|
|
taskAction: buildTaskAction("fill_demand", demandRequirement.id),
|
|
entityId: demandRequirement.id,
|
|
entityType: "demand",
|
|
link: `/projects/${demandRequirement.projectId}`,
|
|
channel: "in_app",
|
|
},
|
|
});
|
|
emitNotificationCreated(manager.id, task.id);
|
|
}
|
|
|
|
checkBudgetThresholdsInBackground(db, demandRequirement.projectId);
|
|
generateAutoSuggestionsInBackground(db, demandRequirement.id);
|
|
|
|
return demandRequirement;
|
|
}
|
|
|
|
async function fillDemandRequirementWithEffects(
|
|
db: import("@capakraken/db").PrismaClient,
|
|
input: z.infer<typeof FillDemandRequirementSchema>,
|
|
) {
|
|
const result = await fillDemandRequirement(db, input);
|
|
|
|
emitAllocationCreated({
|
|
id: result.assignment.id,
|
|
projectId: result.assignment.projectId,
|
|
resourceId: result.assignment.resourceId,
|
|
});
|
|
|
|
emitAllocationUpdated({
|
|
id: result.updatedDemandRequirement.id,
|
|
projectId: result.updatedDemandRequirement.projectId,
|
|
resourceId: null,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(db, result.assignment.projectId);
|
|
|
|
if (result.updatedDemandRequirement.headcount > 0
|
|
&& result.updatedDemandRequirement.status !== "COMPLETED") {
|
|
generateAutoSuggestionsInBackground(db, result.updatedDemandRequirement.id);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
async function resolveAssignmentBySelection(
|
|
db: Pick<import("@capakraken/db").PrismaClient, "assignment">,
|
|
input: AssignmentResolutionInput,
|
|
) {
|
|
if (input.assignmentId) {
|
|
return findUniqueOrThrow(
|
|
db.assignment.findUnique({
|
|
where: { id: input.assignmentId },
|
|
include: ASSIGNMENT_INCLUDE,
|
|
}),
|
|
"Assignment",
|
|
);
|
|
}
|
|
|
|
if (!input.resourceId || !input.projectId) {
|
|
throw new TRPCError({
|
|
code: "BAD_REQUEST",
|
|
message: "resourceId and projectId are required when assignmentId is not provided",
|
|
});
|
|
}
|
|
|
|
const assignments = await db.assignment.findMany({
|
|
where: {
|
|
resourceId: input.resourceId,
|
|
projectId: input.projectId,
|
|
...(input.excludeCancelled ? { status: { not: AllocationStatus.CANCELLED } } : {}),
|
|
},
|
|
include: ASSIGNMENT_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
});
|
|
|
|
const matchingAssignment = assignments
|
|
.filter((assignment) => {
|
|
if (input.selectionMode === "WINDOW") {
|
|
return (!input.startDate || assignment.startDate >= input.startDate)
|
|
&& (!input.endDate || assignment.endDate <= input.endDate);
|
|
}
|
|
|
|
return !input.startDate || toIsoDate(assignment.startDate) === toIsoDate(input.startDate);
|
|
})
|
|
.sort((left, right) => right.startDate.getTime() - left.startDate.getTime())[0] ?? null;
|
|
|
|
if (!matchingAssignment) {
|
|
throw new TRPCError({ code: "NOT_FOUND", message: "Assignment not found" });
|
|
}
|
|
|
|
return matchingAssignment;
|
|
}
|
|
|
|
async function buildResourceAvailabilityView(
|
|
db: Pick<import("@capakraken/db").PrismaClient, "resource" | "assignment" | "vacation" | "holidayCalendar">,
|
|
input: {
|
|
resourceId: string;
|
|
startDate: Date;
|
|
endDate: Date;
|
|
hoursPerDay: number;
|
|
},
|
|
) {
|
|
const resource = await db.resource.findUnique({
|
|
where: { id: input.resourceId },
|
|
select: {
|
|
id: true, displayName: true, eid: true, fte: true,
|
|
availability: true,
|
|
countryId: true,
|
|
federalState: true,
|
|
metroCityId: true,
|
|
country: { select: { dailyWorkingHours: true, code: true } },
|
|
metroCity: { select: { name: true } },
|
|
},
|
|
});
|
|
if (!resource) throw new TRPCError({ code: "NOT_FOUND", message: "Resource not found" });
|
|
|
|
const fallbackDailyHours = (resource.country?.dailyWorkingHours ?? 8) * (resource.fte ?? 1);
|
|
const availability = (resource.availability as WeekdayAvailability | null) ?? {
|
|
monday: fallbackDailyHours,
|
|
tuesday: fallbackDailyHours,
|
|
wednesday: fallbackDailyHours,
|
|
thursday: fallbackDailyHours,
|
|
friday: fallbackDailyHours,
|
|
saturday: 0,
|
|
sunday: 0,
|
|
};
|
|
|
|
const [existingAssignments, vacations] = await Promise.all([
|
|
db.assignment.findMany({
|
|
where: {
|
|
resourceId: input.resourceId,
|
|
status: { not: "CANCELLED" },
|
|
startDate: { lte: input.endDate },
|
|
endDate: { gte: input.startDate },
|
|
},
|
|
select: {
|
|
id: true, startDate: true, endDate: true, hoursPerDay: true, status: true,
|
|
project: { select: { name: true, shortCode: true } },
|
|
},
|
|
orderBy: { startDate: "asc" },
|
|
}),
|
|
db.vacation.findMany({
|
|
where: {
|
|
resourceId: input.resourceId,
|
|
status: { in: ["APPROVED", "PENDING"] },
|
|
startDate: { lte: input.endDate },
|
|
endDate: { gte: input.startDate },
|
|
},
|
|
select: {
|
|
id: true,
|
|
type: true,
|
|
startDate: true,
|
|
endDate: true,
|
|
isHalfDay: true,
|
|
halfDayPart: true,
|
|
status: true,
|
|
},
|
|
orderBy: { startDate: "asc" },
|
|
}),
|
|
]);
|
|
|
|
const contexts = await loadResourceDailyAvailabilityContexts(
|
|
db,
|
|
[{
|
|
id: resource.id,
|
|
availability,
|
|
countryId: resource.countryId,
|
|
countryCode: resource.country?.code,
|
|
federalState: resource.federalState,
|
|
metroCityId: resource.metroCityId,
|
|
metroCityName: resource.metroCity?.name,
|
|
}],
|
|
input.startDate,
|
|
input.endDate,
|
|
);
|
|
const context = contexts.get(resource.id);
|
|
|
|
const totalWorkingDays = countEffectiveWorkingDays({
|
|
availability,
|
|
periodStart: input.startDate,
|
|
periodEnd: input.endDate,
|
|
context,
|
|
});
|
|
let availableDays = 0;
|
|
let conflictDays = 0;
|
|
let partialDays = 0;
|
|
let totalAvailableHours = 0;
|
|
const requestedHpd = input.hoursPerDay;
|
|
|
|
const d = new Date(input.startDate);
|
|
const end = new Date(input.endDate);
|
|
while (d <= end) {
|
|
const effectiveDayCapacity = calculateEffectiveDayAvailability({
|
|
availability,
|
|
date: d,
|
|
context,
|
|
});
|
|
|
|
if (effectiveDayCapacity > 0) {
|
|
let bookedHours = 0;
|
|
for (const assignment of existingAssignments) {
|
|
bookedHours += calculateEffectiveBookedHours({
|
|
availability,
|
|
startDate: assignment.startDate,
|
|
endDate: assignment.endDate,
|
|
hoursPerDay: assignment.hoursPerDay,
|
|
periodStart: d,
|
|
periodEnd: d,
|
|
context,
|
|
});
|
|
}
|
|
|
|
const remainingCapacity = Math.max(0, effectiveDayCapacity - bookedHours);
|
|
if (remainingCapacity >= requestedHpd) {
|
|
availableDays++;
|
|
totalAvailableHours += requestedHpd;
|
|
} else if (remainingCapacity > 0) {
|
|
partialDays++;
|
|
totalAvailableHours += remainingCapacity;
|
|
} else {
|
|
conflictDays++;
|
|
}
|
|
}
|
|
d.setDate(d.getDate() + 1);
|
|
}
|
|
|
|
const totalRequestedHours = totalWorkingDays * requestedHpd;
|
|
const totalPeriodCapacity = calculateEffectiveAvailableHours({
|
|
availability,
|
|
periodStart: input.startDate,
|
|
periodEnd: input.endDate,
|
|
context,
|
|
});
|
|
const dailyCapacity = totalWorkingDays > 0
|
|
? Math.round((totalPeriodCapacity / totalWorkingDays) * 10) / 10
|
|
: 0;
|
|
|
|
return {
|
|
resource: { id: resource.id, name: resource.displayName, eid: resource.eid },
|
|
dailyCapacity,
|
|
totalWorkingDays,
|
|
availableDays,
|
|
partialDays,
|
|
conflictDays,
|
|
totalAvailableHours: Math.round(totalAvailableHours * 10) / 10,
|
|
totalRequestedHours,
|
|
coveragePercent: totalRequestedHours > 0
|
|
? Math.round((totalAvailableHours / totalRequestedHours) * 100)
|
|
: 0,
|
|
existingAssignments: existingAssignments.map((assignment) => ({
|
|
project: assignment.project.name,
|
|
code: assignment.project.shortCode,
|
|
hoursPerDay: assignment.hoursPerDay,
|
|
start: assignment.startDate.toISOString().slice(0, 10),
|
|
end: assignment.endDate.toISOString().slice(0, 10),
|
|
status: assignment.status,
|
|
})),
|
|
vacations: vacations.map((vacation) => ({
|
|
id: vacation.id,
|
|
type: vacation.type,
|
|
status: vacation.status,
|
|
start: vacation.startDate.toISOString().slice(0, 10),
|
|
end: vacation.endDate.toISOString().slice(0, 10),
|
|
isHalfDay: vacation.isHalfDay,
|
|
halfDayPart: vacation.halfDayPart,
|
|
})),
|
|
};
|
|
}
|
|
|
|
function buildResourceAvailabilitySummary(
|
|
availability: Awaited<ReturnType<typeof buildResourceAvailabilityView>>,
|
|
period: { startDate: Date; endDate: Date },
|
|
) {
|
|
const periodAvailableHours = availability.totalRequestedHours > 0
|
|
? round1(availability.dailyCapacity * availability.totalWorkingDays)
|
|
: 0;
|
|
const periodRemainingHours = round1(availability.totalAvailableHours);
|
|
const periodBookedHours = round1(Math.max(0, periodAvailableHours - periodRemainingHours));
|
|
|
|
return {
|
|
resource: availability.resource.name,
|
|
period: `${toIsoDate(period.startDate)} to ${toIsoDate(period.endDate)}`,
|
|
fte: null,
|
|
workingDays: availability.totalWorkingDays,
|
|
periodAvailableHours,
|
|
periodBookedHours,
|
|
periodRemainingHours,
|
|
maxHoursPerDay: availability.dailyCapacity,
|
|
currentBookedHoursPerDay: round1(
|
|
Math.max(
|
|
0,
|
|
availability.dailyCapacity - availability.totalAvailableHours / Math.max(availability.totalWorkingDays, 1),
|
|
),
|
|
),
|
|
availableHoursPerDay: averagePerWorkingDay(availability.totalAvailableHours, availability.totalWorkingDays),
|
|
isFullyAvailable: availability.existingAssignments.length === 0 && availability.vacations.length === 0,
|
|
existingAllocations: availability.existingAssignments.map((assignment) => ({
|
|
project: `${assignment.project} (${assignment.code})`,
|
|
hoursPerDay: assignment.hoursPerDay,
|
|
status: assignment.status,
|
|
start: assignment.start,
|
|
end: assignment.end,
|
|
})),
|
|
vacations: availability.vacations.map((vacation) => ({
|
|
type: vacation.type,
|
|
start: vacation.start,
|
|
end: vacation.end,
|
|
isHalfDay: vacation.isHalfDay,
|
|
})),
|
|
};
|
|
}
|
|
|
|
export const allocationRouter = createTRPCRouter({
|
|
list: planningReadProcedure
|
|
.input(
|
|
z.object({
|
|
projectId: z.string().optional(),
|
|
resourceId: z.string().optional(),
|
|
status: z.nativeEnum(AllocationStatus).optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const readModel = await loadAllocationReadModel(ctx.db, input);
|
|
return readModel.allocations;
|
|
}),
|
|
|
|
listView: planningReadProcedure
|
|
.input(
|
|
z.object({
|
|
projectId: z.string().optional(),
|
|
resourceId: z.string().optional(),
|
|
status: z.nativeEnum(AllocationStatus).optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => loadAllocationReadModel(ctx.db, input)),
|
|
|
|
create: managerProcedure
|
|
.input(CreateAllocationSchema)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const allocation = await ctx.db.$transaction(async (tx) => {
|
|
if (!input.resourceId) {
|
|
const demandRequirement = await createDemandRequirement(
|
|
tx as unknown as Parameters<typeof createDemandRequirement>[0],
|
|
{
|
|
projectId: input.projectId,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
hoursPerDay: input.hoursPerDay,
|
|
percentage: input.percentage,
|
|
role: input.role,
|
|
roleId: input.roleId,
|
|
headcount: input.headcount,
|
|
status: input.status,
|
|
metadata: input.metadata,
|
|
},
|
|
);
|
|
|
|
return buildSplitAllocationReadModel({
|
|
demandRequirements: [demandRequirement],
|
|
assignments: [],
|
|
}).allocations[0]!;
|
|
}
|
|
|
|
const assignment = await createAssignment(
|
|
tx as unknown as Parameters<typeof createAssignment>[0],
|
|
{
|
|
resourceId: input.resourceId,
|
|
projectId: input.projectId,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
hoursPerDay: input.hoursPerDay,
|
|
percentage: input.percentage,
|
|
role: input.role,
|
|
roleId: input.roleId,
|
|
status: input.status,
|
|
metadata: input.metadata,
|
|
},
|
|
);
|
|
|
|
return buildSplitAllocationReadModel({
|
|
demandRequirements: [],
|
|
assignments: [assignment],
|
|
}).allocations[0]!;
|
|
});
|
|
|
|
emitAllocationCreated({
|
|
id: allocation.id,
|
|
projectId: allocation.projectId,
|
|
resourceId: allocation.resourceId,
|
|
});
|
|
dispatchAllocationWebhookInBackground(ctx.db, "allocation.created", {
|
|
id: allocation.id,
|
|
projectId: allocation.projectId,
|
|
resourceId: allocation.resourceId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, allocation.projectId);
|
|
return allocation;
|
|
}),
|
|
|
|
listDemands: planningReadProcedure
|
|
.input(
|
|
z.object({
|
|
projectId: z.string().optional(),
|
|
status: z.nativeEnum(AllocationStatus).optional(),
|
|
roleId: z.string().optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const demands = await ctx.db.demandRequirement.findMany({
|
|
where: {
|
|
...(input.projectId ? { projectId: input.projectId } : {}),
|
|
...(input.status ? { status: input.status } : {}),
|
|
...(input.roleId ? { roleId: input.roleId } : {}),
|
|
},
|
|
include: DEMAND_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
});
|
|
const dir = await getAnonymizationDirectory(ctx.db);
|
|
if (!dir) return demands;
|
|
return demands.map((d) => ({
|
|
...d,
|
|
assignments: d.assignments.map((a) =>
|
|
a.resource ? { ...a, resource: anonymizeResource(a.resource, dir) } : a,
|
|
),
|
|
}));
|
|
}),
|
|
|
|
listAssignments: planningReadProcedure
|
|
.input(
|
|
z.object({
|
|
projectId: z.string().optional(),
|
|
resourceId: z.string().optional(),
|
|
status: z.nativeEnum(AllocationStatus).optional(),
|
|
demandRequirementId: z.string().optional(),
|
|
}),
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const assignments = await ctx.db.assignment.findMany({
|
|
where: {
|
|
...(input.projectId ? { projectId: input.projectId } : {}),
|
|
...(input.resourceId ? { resourceId: input.resourceId } : {}),
|
|
...(input.status ? { status: input.status } : {}),
|
|
...(input.demandRequirementId ? { demandRequirementId: input.demandRequirementId } : {}),
|
|
},
|
|
include: ASSIGNMENT_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
});
|
|
const dir = await getAnonymizationDirectory(ctx.db);
|
|
if (!dir) return assignments;
|
|
return assignments.map((a) =>
|
|
a.resource ? { ...a, resource: anonymizeResource(a.resource, dir) } : a,
|
|
);
|
|
}),
|
|
|
|
getAssignmentById: planningReadProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => {
|
|
const assignment = await findUniqueOrThrow(
|
|
ctx.db.assignment.findUnique({
|
|
where: { id: input.id },
|
|
include: ASSIGNMENT_INCLUDE,
|
|
}),
|
|
"Assignment",
|
|
);
|
|
const dir = await getAnonymizationDirectory(ctx.db);
|
|
if (!dir || !assignment.resource) {
|
|
return assignment;
|
|
}
|
|
return {
|
|
...assignment,
|
|
resource: anonymizeResource(assignment.resource, dir),
|
|
};
|
|
}),
|
|
|
|
resolveAssignment: planningReadProcedure
|
|
.input(z.object({
|
|
assignmentId: z.string().optional(),
|
|
resourceId: z.string().optional(),
|
|
projectId: z.string().optional(),
|
|
startDate: z.coerce.date().optional(),
|
|
endDate: z.coerce.date().optional(),
|
|
selectionMode: z.enum(["WINDOW", "EXACT_START"]).default("EXACT_START"),
|
|
excludeCancelled: z.boolean().default(false),
|
|
}))
|
|
.query(async ({ ctx, input }) => resolveAssignmentBySelection(ctx.db, input)),
|
|
|
|
getDemandRequirementById: planningReadProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ ctx, input }) => getDemandRequirementByIdOrThrow(ctx.db, input.id)),
|
|
|
|
/**
|
|
* Check a resource's availability for a date range.
|
|
* Returns working days, existing allocations, conflict days, and available capacity.
|
|
*/
|
|
checkResourceAvailability: planningReadProcedure
|
|
.input(z.object({
|
|
resourceId: z.string(),
|
|
startDate: z.coerce.date(),
|
|
endDate: z.coerce.date(),
|
|
hoursPerDay: z.number().min(0.5).max(24).default(8),
|
|
}))
|
|
.query(async ({ ctx, input }) => {
|
|
const { vacations: _vacations, ...availability } = await buildResourceAvailabilityView(ctx.db, input);
|
|
return availability;
|
|
}),
|
|
|
|
getResourceAvailabilityView: planningReadProcedure
|
|
.input(z.object({
|
|
resourceId: z.string(),
|
|
startDate: z.coerce.date(),
|
|
endDate: z.coerce.date(),
|
|
hoursPerDay: z.number().min(0.5).max(24).default(8),
|
|
}))
|
|
.query(async ({ ctx, input }) => buildResourceAvailabilityView(ctx.db, input)),
|
|
|
|
getResourceAvailabilitySummary: planningReadProcedure
|
|
.input(z.object({
|
|
resourceId: z.string(),
|
|
startDate: z.coerce.date(),
|
|
endDate: z.coerce.date(),
|
|
hoursPerDay: z.number().min(0.5).max(24).default(8),
|
|
}))
|
|
.query(async ({ ctx, input }) => {
|
|
const availability = await buildResourceAvailabilityView(ctx.db, input);
|
|
return buildResourceAvailabilitySummary(availability, input);
|
|
}),
|
|
|
|
createDemandRequirement: managerProcedure
|
|
.input(CreateDemandRequirementSchema)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
return createDemandRequirementWithEffects(ctx.db, input);
|
|
}),
|
|
|
|
createDemand: managerProcedure
|
|
.input(z.object({
|
|
projectId: z.string(),
|
|
role: z.string().optional(),
|
|
roleId: z.string().optional(),
|
|
headcount: z.number().int().positive().default(1),
|
|
hoursPerDay: z.number().min(0.5).max(24),
|
|
startDate: z.coerce.date(),
|
|
endDate: z.coerce.date(),
|
|
budgetCents: z.number().int().min(0).optional(),
|
|
metadata: z.record(z.string(), z.unknown()).optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
return createDemandRequirementWithEffects(
|
|
ctx.db,
|
|
buildCreateDemandRequirementInput(input),
|
|
);
|
|
}),
|
|
|
|
updateDemandRequirement: managerProcedure
|
|
.input(z.object({ id: z.string(), data: UpdateDemandRequirementSchema }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const updated = await ctx.db.$transaction(async (tx) => {
|
|
return updateDemandRequirement(
|
|
tx as unknown as Parameters<typeof updateDemandRequirement>[0],
|
|
input.id,
|
|
input.data,
|
|
);
|
|
});
|
|
|
|
emitAllocationUpdated({
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: null,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, updated.projectId);
|
|
|
|
return updated;
|
|
}),
|
|
|
|
createAssignment: managerProcedure
|
|
.input(CreateAssignmentSchema)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const assignment = await ctx.db.$transaction(async (tx) => {
|
|
return createAssignment(
|
|
tx as unknown as Parameters<typeof createAssignment>[0],
|
|
input,
|
|
);
|
|
});
|
|
|
|
emitAllocationCreated({
|
|
id: assignment.id,
|
|
projectId: assignment.projectId,
|
|
resourceId: assignment.resourceId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, assignment.projectId);
|
|
|
|
return assignment;
|
|
}),
|
|
|
|
ensureAssignment: managerProcedure
|
|
.input(z.object({
|
|
resourceId: z.string(),
|
|
projectId: z.string(),
|
|
startDate: z.coerce.date(),
|
|
endDate: z.coerce.date(),
|
|
hoursPerDay: z.number().min(0.5).max(24),
|
|
role: z.string().optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const existing = (await ctx.db.assignment.findMany({
|
|
where: {
|
|
resourceId: input.resourceId,
|
|
projectId: input.projectId,
|
|
},
|
|
include: ASSIGNMENT_INCLUDE,
|
|
orderBy: { startDate: "asc" },
|
|
})).find((assignment) => (
|
|
toIsoDate(assignment.startDate) === toIsoDate(input.startDate)
|
|
&& toIsoDate(assignment.endDate) === toIsoDate(input.endDate)
|
|
));
|
|
|
|
if (existing) {
|
|
if (existing.status !== AllocationStatus.CANCELLED) {
|
|
throw new TRPCError({
|
|
code: "CONFLICT",
|
|
message: `An allocation already exists for this resource/project/dates with status ${existing.status}.`,
|
|
});
|
|
}
|
|
|
|
const resource = await ctx.db.resource.findUnique({
|
|
where: { id: input.resourceId },
|
|
select: { lcrCents: true },
|
|
});
|
|
if (!resource) {
|
|
throw new TRPCError({ code: "NOT_FOUND", message: "Resource not found" });
|
|
}
|
|
|
|
const updated = await ctx.db.$transaction(async (tx) => updateAssignment(
|
|
tx as unknown as Parameters<typeof updateAssignment>[0],
|
|
existing.id,
|
|
{
|
|
status: AllocationStatus.PROPOSED,
|
|
hoursPerDay: input.hoursPerDay,
|
|
percentage: (input.hoursPerDay / 8) * 100,
|
|
dailyCostCents: Math.round(resource.lcrCents * input.hoursPerDay),
|
|
...(input.role ? { role: input.role } : {}),
|
|
},
|
|
));
|
|
|
|
emitAllocationUpdated({
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: updated.resourceId,
|
|
});
|
|
dispatchAllocationWebhookInBackground(ctx.db, "allocation.updated", {
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: updated.resourceId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, updated.projectId);
|
|
|
|
return { assignment: updated, action: "reactivated" as const };
|
|
}
|
|
|
|
const assignment = await ctx.db.$transaction(async (tx) => createAssignment(
|
|
tx as unknown as Parameters<typeof createAssignment>[0],
|
|
{
|
|
resourceId: input.resourceId,
|
|
projectId: input.projectId,
|
|
startDate: input.startDate,
|
|
endDate: input.endDate,
|
|
hoursPerDay: input.hoursPerDay,
|
|
percentage: (input.hoursPerDay / 8) * 100,
|
|
status: AllocationStatus.PROPOSED,
|
|
metadata: {},
|
|
...(input.role ? { role: input.role } : {}),
|
|
},
|
|
));
|
|
|
|
emitAllocationCreated({
|
|
id: assignment.id,
|
|
projectId: assignment.projectId,
|
|
resourceId: assignment.resourceId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, assignment.projectId);
|
|
|
|
return { assignment, action: "created" as const };
|
|
}),
|
|
|
|
updateAssignment: managerProcedure
|
|
.input(z.object({ id: z.string(), data: UpdateAssignmentSchema }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const existing = await findUniqueOrThrow(
|
|
ctx.db.assignment.findUnique({
|
|
where: { id: input.id },
|
|
select: { resourceId: true },
|
|
}),
|
|
"Assignment",
|
|
);
|
|
|
|
const updated = await ctx.db.$transaction(async (tx) => {
|
|
return updateAssignment(
|
|
tx as unknown as Parameters<typeof updateAssignment>[0],
|
|
input.id,
|
|
input.data,
|
|
);
|
|
});
|
|
|
|
emitAllocationUpdated({
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: updated.resourceId,
|
|
resourceIds: [existing.resourceId, updated.resourceId],
|
|
});
|
|
dispatchAllocationWebhookInBackground(ctx.db, "allocation.updated", {
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: updated.resourceId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, updated.projectId);
|
|
|
|
return updated;
|
|
}),
|
|
|
|
deleteDemandRequirement: managerProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const existing = await findUniqueOrThrow(
|
|
ctx.db.demandRequirement.findUnique({
|
|
where: { id: input.id },
|
|
include: DEMAND_INCLUDE,
|
|
}),
|
|
"Demand requirement",
|
|
);
|
|
|
|
await ctx.db.$transaction(async (tx) => {
|
|
await deleteDemandRequirement(
|
|
tx as unknown as Parameters<typeof deleteDemandRequirement>[0],
|
|
input.id,
|
|
);
|
|
|
|
await tx.auditLog.create({
|
|
data: {
|
|
entityType: "DemandRequirement",
|
|
entityId: input.id,
|
|
action: "DELETE",
|
|
changes: { before: existing } as unknown as import("@capakraken/db").Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
});
|
|
|
|
emitAllocationDeleted(existing.id, existing.projectId);
|
|
dispatchAllocationWebhookInBackground(ctx.db, "allocation.deleted", {
|
|
id: existing.id,
|
|
projectId: existing.projectId,
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, existing.projectId);
|
|
|
|
return { success: true };
|
|
}),
|
|
|
|
fillDemandRequirement: managerProcedure
|
|
.input(FillDemandRequirementSchema)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
return fillDemandRequirementWithEffects(ctx.db, input);
|
|
}),
|
|
|
|
assignResourceToDemand: managerProcedure
|
|
.input(z.object({
|
|
demandRequirementId: z.string(),
|
|
resourceId: z.string(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const result = await fillDemandRequirementWithEffects(ctx.db, input);
|
|
const demandRequirement = await getDemandRequirementByIdOrThrow(
|
|
ctx.db,
|
|
input.demandRequirementId,
|
|
);
|
|
|
|
return {
|
|
...result,
|
|
demandRequirement,
|
|
};
|
|
}),
|
|
|
|
fillOpenDemandByAllocation: managerProcedure
|
|
.input(FillOpenDemandByAllocationSchema)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const result = await fillOpenDemand(ctx.db, input);
|
|
|
|
emitAllocationCreated(result.createdAllocation);
|
|
|
|
if (result.updatedAllocation) {
|
|
emitAllocationUpdated(result.updatedAllocation);
|
|
}
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, result.createdAllocation.projectId as string);
|
|
|
|
return result;
|
|
}),
|
|
|
|
update: managerProcedure
|
|
.input(z.object({ id: z.string(), data: UpdateAllocationSchema }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const existing = await loadAllocationEntry(ctx.db, input.id);
|
|
|
|
const updated = await ctx.db.$transaction(async (tx) => {
|
|
const { allocation: updatedAllocation } = await updateAllocationEntry(
|
|
tx as unknown as Parameters<typeof updateAllocationEntry>[0],
|
|
{
|
|
id: input.id,
|
|
demandRequirementUpdate:
|
|
existing.kind === "assignment" ? {} : toDemandRequirementUpdateInput(input.data),
|
|
assignmentUpdate:
|
|
existing.kind === "demand" ? {} : toAssignmentUpdateInput(input.data),
|
|
},
|
|
);
|
|
|
|
await tx.auditLog.create({
|
|
data: {
|
|
entityType: "Allocation",
|
|
entityId: input.id,
|
|
action: "UPDATE",
|
|
changes: {
|
|
before: existing.entry,
|
|
after: updatedAllocation,
|
|
} as unknown as import("@capakraken/db").Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
|
|
return updatedAllocation;
|
|
});
|
|
|
|
emitAllocationUpdated({
|
|
id: updated.id,
|
|
projectId: updated.projectId,
|
|
resourceId: updated.resourceId,
|
|
resourceIds: [existing.entry.resourceId, updated.resourceId],
|
|
});
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, updated.projectId);
|
|
|
|
return updated;
|
|
}),
|
|
|
|
deleteAssignment: managerProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
|
|
const existing = await findUniqueOrThrow(
|
|
ctx.db.assignment.findUnique({
|
|
where: { id: input.id },
|
|
include: ASSIGNMENT_INCLUDE,
|
|
}),
|
|
"Assignment",
|
|
);
|
|
|
|
await ctx.db.$transaction(async (tx) => {
|
|
await deleteAssignment(
|
|
tx as unknown as Parameters<typeof deleteAssignment>[0],
|
|
input.id,
|
|
);
|
|
|
|
await tx.auditLog.create({
|
|
data: {
|
|
entityType: "Assignment",
|
|
entityId: input.id,
|
|
action: "DELETE",
|
|
changes: { before: existing } as unknown as import("@capakraken/db").Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
});
|
|
|
|
emitAllocationDeleted(existing.id, existing.projectId, existing.resourceId);
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, existing.projectId);
|
|
|
|
return { success: true };
|
|
}),
|
|
|
|
delete: managerProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const existing = await loadAllocationEntry(ctx.db, input.id);
|
|
|
|
await ctx.db.$transaction(async (tx) => {
|
|
await deleteAllocationEntry(
|
|
tx as unknown as Parameters<typeof deleteAllocationEntry>[0],
|
|
existing,
|
|
);
|
|
|
|
await tx.auditLog.create({
|
|
data: {
|
|
entityType: "Allocation",
|
|
entityId: input.id,
|
|
action: "DELETE",
|
|
changes: { before: existing.entry } as unknown as import("@capakraken/db").Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
});
|
|
|
|
emitAllocationDeleted(existing.entry.id, existing.projectId, existing.entry.resourceId);
|
|
invalidateDashboardCacheInBackground();
|
|
checkBudgetThresholdsInBackground(ctx.db, existing.projectId);
|
|
|
|
return { success: true };
|
|
}),
|
|
|
|
batchDelete: managerProcedure
|
|
.input(z.object({ ids: z.array(z.string()).min(1).max(100) }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const existing = (
|
|
await Promise.all(input.ids.map(async (id) => findAllocationEntryOrNull(ctx.db, id)))
|
|
).filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));
|
|
|
|
await ctx.db.$transaction(async (tx) => {
|
|
for (const allocation of existing) {
|
|
await deleteAllocationEntry(
|
|
tx as unknown as Parameters<typeof deleteAllocationEntry>[0],
|
|
allocation,
|
|
);
|
|
}
|
|
await tx.auditLog.create({
|
|
data: {
|
|
entityType: "Allocation",
|
|
entityId: input.ids.join(","),
|
|
action: "DELETE",
|
|
changes: {
|
|
before: existing.map((a) => ({ id: a.entry.id, projectId: a.projectId })),
|
|
} as unknown as import("@capakraken/db").Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
});
|
|
|
|
for (const a of existing) {
|
|
emitAllocationDeleted(a.entry.id, a.projectId, a.entry.resourceId);
|
|
}
|
|
invalidateDashboardCacheInBackground();
|
|
// Check budget thresholds for each affected project
|
|
const affectedProjectIds = [...new Set(existing.map((a) => a.projectId))];
|
|
for (const pid of affectedProjectIds) {
|
|
checkBudgetThresholdsInBackground(ctx.db, pid);
|
|
}
|
|
|
|
return { count: existing.length };
|
|
}),
|
|
|
|
batchUpdateStatus: managerProcedure
|
|
.input(
|
|
z.object({
|
|
ids: z.array(z.string()).min(1).max(100),
|
|
status: z.nativeEnum(AllocationStatus),
|
|
}),
|
|
)
|
|
.mutation(async ({ ctx, input }) => {
|
|
requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
|
|
const updated = await ctx.db.$transaction(async (tx) => {
|
|
const updatedAllocations = await Promise.all(
|
|
input.ids.map(async (id) =>
|
|
(
|
|
await updateAllocationEntry(
|
|
tx as unknown as Parameters<typeof updateAllocationEntry>[0],
|
|
{
|
|
id,
|
|
demandRequirementUpdate: { status: input.status },
|
|
assignmentUpdate: { status: input.status },
|
|
},
|
|
)
|
|
).allocation,
|
|
),
|
|
);
|
|
|
|
return updatedAllocations;
|
|
});
|
|
|
|
await ctx.db.auditLog.create({
|
|
data: {
|
|
entityType: "Allocation",
|
|
entityId: input.ids.join(","),
|
|
action: "UPDATE",
|
|
changes: { after: { status: input.status, ids: input.ids } },
|
|
},
|
|
});
|
|
|
|
for (const a of updated) {
|
|
emitAllocationUpdated({ id: a.id, projectId: a.projectId, resourceId: a.resourceId });
|
|
}
|
|
invalidateDashboardCacheInBackground();
|
|
// Check budget thresholds for each affected project
|
|
const affectedProjectIds = [...new Set(updated.map((a) => a.projectId))];
|
|
for (const pid of affectedProjectIds) {
|
|
checkBudgetThresholdsInBackground(ctx.db, pid);
|
|
}
|
|
|
|
return { count: updated.length };
|
|
}),
|
|
});
|