Hartmut/CapaKraken
1
0
Fork 0
Code Issues 10 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor(api): extract timeline project context support

Browse Source
This commit is contained in:
Hartmut Nörenberg
2026-03-31 15:00:01 +02:00
parent b669de54e1
commit e1de9a3a98
3 changed files with 379 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/api/src/router/timeline-project-context-support.ts
+160
View File
@@ -0,0 +1,160 @@
import { TRPCError } from "@trpc/server";
import { summarizeHolidayOverlays, type formatHolidayOverlays } from "./timeline-holiday-read.js";
import {
createTimelineDateRange,
fmtDate,
rangesOverlap,
summarizeTimelineEntries,
toDate,
} from "./timeline-read-shared.js";
export interface ResolveTimelineProjectContextPeriodInput {
requestedStartDate?: string | undefined;
requestedEndDate?: string | undefined;
durationDays?: number | undefined;
projectStartDate?: Date | null | undefined;
projectEndDate?: Date | null | undefined;
firstAssignmentStartDate?: Date | string | null | undefined;
firstDemandStartDate?: Date | string | null | undefined;
}
export function resolveTimelineProjectContextPeriod(
input: ResolveTimelineProjectContextPeriodInput,
) {
const startDate = input.requestedStartDate
? createTimelineDateRange({
startDate: input.requestedStartDate,
durationDays: 1,
}).startDate
: input.projectStartDate
?? (input.firstAssignmentStartDate ? toDate(input.firstAssignmentStartDate) : null)
?? (input.firstDemandStartDate ? toDate(input.firstDemandStartDate) : null)
?? createTimelineDateRange({ durationDays: 1 }).startDate;
const endDate = input.requestedEndDate
? createTimelineDateRange({
startDate: fmtDate(startDate) ?? undefined,
endDate: input.requestedEndDate,
}).endDate
: input.projectEndDate
?? createTimelineDateRange({
startDate: fmtDate(startDate) ?? undefined,
durationDays: input.durationDays ?? 21,
}).endDate;
if (endDate < startDate) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "endDate must be on or after startDate.",
});
}
return { startDate, endDate };
}
export interface TimelineProjectAssignmentConflict {
assignmentId: string;
resourceId: string;
resourceName: string | null;
startDate: string | null;
endDate: string | null;
hoursPerDay: number;
overlapCount: number;
crossProjectOverlapCount: number;
overlaps: Array<{
id: string;
projectId: string | null;
projectName: string | null;
projectShortCode: string | null;
startDate: string | null;
endDate: string | null;
hoursPerDay: number;
status: string;
sameProject: boolean;
}>;
}
export function buildTimelineProjectAssignmentConflicts(input: {
projectId: string;
assignments: Array<{
id: string;
resourceId: string | null;
resource?: { displayName?: string | null } | null;
startDate: Date | string;
endDate: Date | string;
hoursPerDay: number;
}>;
allResourceAllocations: Array<{
id: string;
resourceId: string | null;
projectId: string | null;
project?: { name?: string | null; shortCode?: string | null } | null;
startDate: Date | string;
endDate: Date | string;
hoursPerDay: number;
status: string;
}>;
}): TimelineProjectAssignmentConflict[] {
return input.assignments
.filter((assignment) => assignment.resourceId && assignment.resource)
.map((assignment) => {
const overlaps = input.allResourceAllocations
.filter((booking) => (
booking.resourceId === assignment.resourceId
&& booking.id !== assignment.id
&& rangesOverlap(
toDate(booking.startDate),
toDate(booking.endDate),
toDate(assignment.startDate),
toDate(assignment.endDate),
)
))
.map((booking) => ({
id: booking.id,
projectId: booking.projectId,
projectName: booking.project?.name ?? null,
projectShortCode: booking.project?.shortCode ?? null,
startDate: fmtDate(toDate(booking.startDate)),
endDate: fmtDate(toDate(booking.endDate)),
hoursPerDay: booking.hoursPerDay,
status: booking.status,
sameProject: booking.projectId === input.projectId,
}));
return {
assignmentId: assignment.id,
resourceId: assignment.resourceId!,
resourceName: assignment.resource?.displayName ?? null,
startDate: fmtDate(toDate(assignment.startDate)),
endDate: fmtDate(toDate(assignment.endDate)),
hoursPerDay: assignment.hoursPerDay,
overlapCount: overlaps.length,
crossProjectOverlapCount: overlaps.filter((booking) => !booking.sameProject).length,
overlaps,
};
});
}
export function buildTimelineProjectContextSummary(input: {
allocations: Array<{ projectId: string | null; resourceId: string | null }>;
demands: Array<{ projectId: string | null }>;
assignments: Array<{ projectId: string | null; resourceId: string | null }>;
resourceIds: string[];
allResourceAllocations: unknown[];
assignmentConflicts: Array<{ crossProjectOverlapCount: number }>;
holidayOverlays: ReturnType<typeof formatHolidayOverlays>;
}) {
return {
...summarizeTimelineEntries({
allocations: input.allocations,
demands: input.demands,
assignments: input.assignments,
}),
resourceIds: input.resourceIds.length,
allResourceAllocationCount: input.allResourceAllocations.length,
conflictedAssignmentCount: input.assignmentConflicts.filter(
(item) => item.crossProjectOverlapCount > 0,
).length,
...summarizeHolidayOverlays(input.holidayOverlays),
};
}
packages/api/src/router/timeline-project-read.ts
+38 -92
View File
@@ -1,24 +1,25 @@
import { listAssignmentBookings } from "@capakraken/application";
import { computeBudgetStatus, validateShift } from "@capakraken/engine";
import { computeBudgetStatus } from "@capakraken/engine";
import { ShiftProjectSchema } from "@capakraken/shared";
import { TRPCError } from "@trpc/server";
import { z } from "zod";
import { findUniqueOrThrow } from "../db/helpers.js";
import { getAnonymizationDirectory } from "../lib/anonymization.js";
import { controllerProcedure } from "../trpc.js";
import { loadProjectPlanningReadModel } from "./project-planning-read-model.js";
import {
buildTimelineProjectAssignmentConflicts,
buildTimelineProjectContextSummary,
resolveTimelineProjectContextPeriod,
} from "./timeline-project-context-support.js";
import { buildTimelineShiftPlan } from "./timeline-shift-planning.js";
import { loadTimelineHolidayOverlays, formatHolidayOverlays, summarizeHolidayOverlays } from "./timeline-holiday-read.js";
import { loadTimelineHolidayOverlays, formatHolidayOverlays } from "./timeline-holiday-read.js";
import {
anonymizeResourceOnEntry,
createTimelineDateRange,
fmtDate,
getAssignmentResourceIds,
rangesOverlap,
ShiftDbClient,
summarizeTimelineEntries,
toDate,
} from "./timeline-read-shared.js";
import { buildTimelineProjectShiftValidation } from "./timeline-shift-support.js";
export async function loadProjectShiftContext(db: ShiftDbClient, projectId: string) {
const [project, planningRead] = await Promise.all([
@@ -124,19 +125,12 @@ export async function previewTimelineProjectShift(
newEndDate: Date;
},
) {
const { project, shiftPlan } = await loadProjectShiftContext(db, input.projectId);
const context = await loadProjectShiftContext(db, input.projectId);
return validateShift({
project: {
id: project.id,
budgetCents: project.budgetCents,
winProbability: project.winProbability,
startDate: project.startDate,
endDate: project.endDate,
},
return buildTimelineProjectShiftValidation({
context,
newStartDate: input.newStartDate,
newEndDate: input.newEndDate,
allocations: shiftPlan.validationAllocations,
});
}
@@ -182,94 +176,46 @@ export const timelineProjectReadProcedures = {
.query(async ({ ctx, input }) => {
const projectContext = await loadTimelineProjectContext(ctx.db, input.projectId);
const directory = await getAnonymizationDirectory(ctx.db);
const derivedStartDate = input.startDate
? createTimelineDateRange({ startDate: input.startDate, durationDays: 1 }).startDate
: projectContext.project.startDate
?? projectContext.assignments[0]?.startDate
?? projectContext.demands[0]?.startDate
?? createTimelineDateRange({ durationDays: 1 }).startDate;
const derivedEndDate = input.endDate
? createTimelineDateRange({ startDate: fmtDate(derivedStartDate) ?? undefined, endDate: input.endDate }).endDate
: projectContext.project.endDate
?? createTimelineDateRange({
startDate: fmtDate(derivedStartDate) ?? undefined,
durationDays: input.durationDays ?? 21,
}).endDate;
if (derivedEndDate < derivedStartDate) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "endDate must be on or after startDate.",
});
}
const period = resolveTimelineProjectContextPeriod({
requestedStartDate: input.startDate,
requestedEndDate: input.endDate,
durationDays: input.durationDays,
projectStartDate: projectContext.project.startDate,
projectEndDate: projectContext.project.endDate,
firstAssignmentStartDate: projectContext.assignments[0]?.startDate,
firstDemandStartDate: projectContext.demands[0]?.startDate,
});
const holidayOverlays = projectContext.resourceIds.length > 0
? await loadTimelineHolidayOverlays(ctx.db, {
startDate: derivedStartDate,
endDate: derivedEndDate,
startDate: period.startDate,
endDate: period.endDate,
resourceIds: projectContext.resourceIds,
projectIds: [input.projectId],
})
: [];
const formattedHolidayOverlays = formatHolidayOverlays(holidayOverlays);
const assignmentConflicts = projectContext.assignments
.filter((assignment) => assignment.resourceId && assignment.resource)
.map((assignment) => {
const overlaps = projectContext.allResourceAllocations
.filter((booking) => (
booking.resourceId === assignment.resourceId
&& booking.id !== assignment.id
&& rangesOverlap(
toDate(booking.startDate),
toDate(booking.endDate),
toDate(assignment.startDate),
toDate(assignment.endDate),
)
))
.map((booking) => ({
id: booking.id,
projectId: booking.projectId,
projectName: booking.project?.name ?? null,
projectShortCode: booking.project?.shortCode ?? null,
startDate: fmtDate(toDate(booking.startDate)),
endDate: fmtDate(toDate(booking.endDate)),
hoursPerDay: booking.hoursPerDay,
status: booking.status,
sameProject: booking.projectId === input.projectId,
}));
return {
assignmentId: assignment.id,
resourceId: assignment.resourceId!,
resourceName: assignment.resource?.displayName ?? null,
startDate: fmtDate(toDate(assignment.startDate)),
endDate: fmtDate(toDate(assignment.endDate)),
hoursPerDay: assignment.hoursPerDay,
overlapCount: overlaps.length,
crossProjectOverlapCount: overlaps.filter((booking) => !booking.sameProject).length,
overlaps,
};
});
const assignmentConflicts = buildTimelineProjectAssignmentConflicts({
projectId: input.projectId,
assignments: projectContext.assignments,
allResourceAllocations: projectContext.allResourceAllocations,
});
return {
project: projectContext.project,
period: {
startDate: fmtDate(derivedStartDate),
endDate: fmtDate(derivedEndDate),
},
summary: {
...summarizeTimelineEntries({
allocations: projectContext.allocations,
demands: projectContext.demands,
assignments: projectContext.assignments,
}),
resourceIds: projectContext.resourceIds.length,
allResourceAllocationCount: projectContext.allResourceAllocations.length,
conflictedAssignmentCount: assignmentConflicts.filter((item) => item.crossProjectOverlapCount > 0).length,
...summarizeHolidayOverlays(formattedHolidayOverlays),
startDate: fmtDate(period.startDate),
endDate: fmtDate(period.endDate),
},
summary: buildTimelineProjectContextSummary({
allocations: projectContext.allocations,
demands: projectContext.demands,
assignments: projectContext.assignments,
resourceIds: projectContext.resourceIds,
allResourceAllocations: projectContext.allResourceAllocations,
assignmentConflicts,
holidayOverlays: formattedHolidayOverlays,
}),
allocations: projectContext.allocations.map((allocation) =>
anonymizeResourceOnEntry(allocation, directory),
),