Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/demo-pro-seed/operations.ts
T

964 lines
38 KiB
TypeScript

import type { DemoProSeedGraph, ProjectType, SeedProject } from "./types";
import { buildSeedFileObjectMetadata } from "./file-objects";
export const OPERATIONAL_COUNTS = {
projectContacts: 1_611,
projectMembers: 1_876,
tasks: 1_684,
taskWatchers: 421,
activities: 2_731,
scheduleEntries: 1_147,
scheduleConflicts: 23,
calendarEvents: 613,
projectAppointments: 613,
bookingPages: 3,
bookingProviders: 21,
availabilityRules: 35,
availabilityExceptions: 7,
bookingAppointments: 79,
invoices: 347,
checklists: 329,
checklistItems: 1_693,
files: 917,
acceptances: 73,
acceptanceSignatures: 146,
signatureDocuments: 47,
signatureSigners: 47,
} as const;
type ProjectContact = {
id: string;
projectId: string;
contactId: string;
role: "auftraggeber" | "bauherr" | "rechnungsempfaenger" | "ansprechpartner";
primary: boolean;
};
type ProjectMember = {
id: string;
projectId: string;
userId: string | null;
groupId: string | null;
role: "monteur" | "projektleiter" | "zustaendig";
};
type SeedTask = {
id: string;
projectId: string;
title: string;
description: string;
status: "open" | "in_progress" | "blocked" | "done" | "cancelled";
priority: "low" | "normal" | "high" | "urgent";
deadline: string;
assignedToUserId: string | null;
assignedToGroupId: string | null;
completedAt: string | null;
createdAt: string;
updatedAt: string;
};
type SeedActivity = {
id: string;
projectId: string;
actorUserId: string;
activityType: string;
createdAt: string;
summaryText: string;
metadata: Record<string, unknown>;
};
type SeedScheduleEntry = {
id: string;
projectId: string;
assignedUserId: string;
title: string;
startAt: string;
endAt: string;
status: "planned" | "confirmed" | "in_progress" | "done" | "cancelled";
calendarEventId: string | null;
syncStatus: "pending" | "synced";
};
type SeedCalendarEvent = {
id: string;
projectId: string;
userId: string;
title: string;
description: string;
location: string;
startsAt: string;
endsAt: string;
};
type SeedBookingPage = {
id: string;
slug: string;
title: string;
description: string;
durationMinutes: number;
};
type SeedBookingAppointment = {
id: string;
bookingPageId: string;
providerUserId: string;
contactId: string;
projectId: string;
internalCalendarEventId: string;
startsAt: string;
endsAt: string;
status: "scheduled" | "held" | "cancelled";
customerName: string;
customerEmail: string;
customerPhone: string;
request: string;
};
type SeedInvoice = {
id: string;
projectId: string;
invoiceNumber: string;
amount: string;
status: "entwurf" | "gestellt" | "bezahlt" | "storniert";
date: string;
dueAt: string;
fileId: string | null;
createdAt: string;
updatedAt: string;
};
type SeedChecklist = {
id: string;
projectId: string;
title: string;
type: "generisch" | "maengel" | "abnahme_doku";
};
type SeedChecklistItem = {
id: string;
checklistId: string;
title: string;
status: "offen" | "erledigt" | "entfaellt";
defectClass: string | null;
assignedToUserId: string;
dueAt: string;
position: number;
photoFileId: null;
};
type SeedFile = {
id: string;
projectId: string;
displayName: string;
mimeType: string;
sizeBytes: number;
checksumSha256: string;
assignedToUserId: string;
tags: string[];
notes: string;
linkRole: string;
createdAt: string;
updatedAt: string;
};
type SeedAcceptance = {
id: string;
projectId: string;
checklistId: string | null;
creatorUserId: string;
date: string;
kind: "full" | "with_defects";
attendees: string[];
remarks: string;
customerEmail: string;
documentFileId: string | null;
createdAt: string;
updatedAt: string;
};
type SeedSignatureDocument = {
id: string;
projectId: string;
sourceFileId: string;
creatorUserId: string;
status: "sent" | "viewed" | "signed";
title: string;
sentAt: string;
completedAt: string | null;
signerContactId: string;
signerEmail: string;
signerName: string;
createdAt: string;
updatedAt: string;
};
export type DemoProOperationalGraph = {
projectContacts: ProjectContact[];
projectMembers: ProjectMember[];
tasks: SeedTask[];
taskWatchers: Array<{ id: string; taskId: string; userId: string }>;
activities: SeedActivity[];
scheduleEntries: SeedScheduleEntry[];
scheduleConflicts: Array<{ id: string; entryId: string; sourceEntryId: string; resolvedAt: string | null }>;
calendarEvents: SeedCalendarEvent[];
projectAppointments: Array<SeedCalendarEvent & { status: "geplant" | "bestaetigt" | "erledigt" | "abgesagt" }>;
bookingPages: SeedBookingPage[];
bookingProviders: Array<{ id: string; bookingPageId: string; providerUserId: string; displayOrder: number }>;
availabilityRules: Array<{
id: string;
providerUserId: string;
dayOfWeek: "monday" | "tuesday" | "wednesday" | "thursday" | "friday";
startTime: string;
endTime: string;
}>;
availabilityExceptions: Array<{
id: string;
providerUserId: string;
date: string;
kind: "unavailable" | "custom_window";
startTime: string | null;
endTime: string | null;
reason: string;
}>;
bookingAppointments: SeedBookingAppointment[];
invoices: SeedInvoice[];
checklists: SeedChecklist[];
checklistItems: SeedChecklistItem[];
files: SeedFile[];
acceptances: SeedAcceptance[];
acceptanceSignatures: Array<{ id: string; acceptanceId: string; signerName: string; signerRole: "kunde" | "monteur"; signedAt: string }>;
signatureDocuments: SeedSignatureDocument[];
signatureSigners: Array<{
id: string;
documentId: string;
contactId: string;
email: string;
name: string;
status: "sent" | "viewed" | "signed";
signedAt: string | null;
}>;
};
const taskTemplates: Readonly<Record<ProjectType, readonly string[]>> = {
reparatur_notdienst: [
"Störungsbild telefonisch aufnehmen",
"Ersatzteile und Werkzeug disponieren",
"Einsatzbericht mit Messwerten abschließen",
"Kunden über Folgemaßnahmen informieren",
],
wartung_pruefung: [
"Anlagendaten und Wartungshistorie prüfen",
"Wartungsmaterial zusammenstellen",
"Mess- und Wartungsprotokoll erfassen",
"Nächsten Wartungszyklus vormerken",
],
heizungstausch: [
"Heizlast und Bestandssituation prüfen",
"Wärmeerzeuger und Speicher disponieren",
"Montageablauf mit Kunde abstimmen",
"Inbetriebnahme und Einweisung dokumentieren",
],
heizungsoptimierung: [
"Bestandswerte und Heizkreise aufnehmen",
"Einstellwerte berechnen",
"Optimierungsmaßnahmen ausführen",
"Verbrauchsempfehlungen dokumentieren",
],
badsanierung: [
"Aufmaß und Ausstattungsdetails bestätigen",
"Sanitärobjekte und Armaturen disponieren",
"Gewerkeablauf koordinieren",
"Abnahme und Pflegehinweise vorbereiten",
],
sanitaer_rohrarbeiten: [
"Leitungsverlauf und Absperrungen prüfen",
"Rohrmaterial disponieren",
"Druckprobe dokumentieren",
"Bestandsunterlagen aktualisieren",
],
objekt_neubau: [
"Ausführungsplanung mit Fachplanung abstimmen",
"Bauzeitenplan und Materialabrufe aktualisieren",
"Montagefortschritt dokumentieren",
"Teilabnahme vorbereiten",
],
lueftung_klima: [
"Luftmengen und Aufstellorte prüfen",
"Geräte und Kanalmaterial disponieren",
"Anlage montieren und einregulieren",
"Messprotokoll und Einweisung abschließen",
],
};
const activityTemplates = [
["project.created", "Projekt wurde vollständig angelegt"],
["project.contact_linked", "Kunden- und Ansprechpartner wurden verknüpft"],
["project.assignment_changed", "Projektteam und Zuständigkeiten wurden geplant"],
["project.schedule_planned", "Ausführungstermin wurde in der Plantafel reserviert"],
["project.note_added", "Technische Projektnotiz wurde ergänzt"],
["project.stage_changed", "Pipeline-Status wurde aktualisiert"],
] as const;
function id(kind: string, index: number): string {
return `rheinmain-shk-v1-${kind}-${String(index + 1).padStart(5, "0")}`;
}
function addDays(value: string, days: number, hour?: number): string {
const date = new Date(value);
date.setUTCDate(date.getUTCDate() + days);
if (hour !== undefined) date.setUTCHours(hour, 0, 0, 0);
return date.toISOString();
}
function earlierDate(first: string, second: string): string {
return new Date(first) <= new Date(second) ? first : second;
}
function laterDate(first: string, second: string): string {
return new Date(first) >= new Date(second) ? first : second;
}
function euro(value: string | null, factor: number): string {
const amount = Number(value ?? 0);
return Math.max(90, Math.round((amount * factor) / 10) * 10).toFixed(2);
}
function contactDisplayName(graph: DemoProSeedGraph, contactId: string): string {
const organization = graph.organizations.find((contact) => contact.id === contactId);
if (organization) return organization.orgName;
const person = graph.persons.find((contact) => contact.id === contactId);
return person ? `${person.firstName} ${person.lastName}` : "Kunde";
}
function contactEmail(graph: DemoProSeedGraph, contactId: string): string {
return (
graph.organizations.find((contact) => contact.id === contactId)?.email ??
graph.persons.find((contact) => contact.id === contactId)?.email ??
"kunde@unbekannt.example.test"
);
}
function contactPhone(graph: DemoProSeedGraph, contactId: string): string {
return (
graph.organizations.find((contact) => contact.id === contactId)?.phone ??
graph.persons.find((contact) => contact.id === contactId)?.phone ??
"+496990009000"
);
}
function employeeDisplayName(graph: DemoProSeedGraph, employeeId: string): string {
const employee = graph.employees.find(({ id: currentId }) => currentId === employeeId);
return employee ? `${employee.firstName} ${employee.lastName}` : "Mitarbeiter";
}
export function generateOperationalGraph(graph: DemoProSeedGraph): DemoProOperationalGraph {
const crewById = new Map(graph.crews.map((crew) => [crew.id, crew]));
const projectContacts: ProjectContact[] = [];
const projectMembers: ProjectMember[] = [];
const tasks: SeedTask[] = [];
const activities: SeedActivity[] = [];
const scheduleEntries: SeedScheduleEntry[] = [];
const calendarEvents: SeedCalendarEvent[] = [];
const projectAppointments: DemoProOperationalGraph["projectAppointments"] = [];
for (const [projectIndex, project] of graph.projects.entries()) {
for (const contact of project.contacts) {
projectContacts.push({
id: id("project-contact", projectContacts.length),
projectId: project.id,
contactId: contact.contactId,
role: contact.role,
primary: contact.primary,
});
}
const crew = crewById.get(project.crewIds[0]!)!;
projectMembers.push({
id: id("project-member", projectMembers.length),
projectId: project.id,
userId: project.projectManagerEmployeeId,
groupId: null,
role: "projektleiter",
});
for (const userId of crew.memberEmployeeIds) {
projectMembers.push({ id: id("project-member", projectMembers.length), projectId: project.id, userId, groupId: null, role: "monteur" });
}
for (const additionalCrewId of project.crewIds.slice(1)) {
const additionalCrew = crewById.get(additionalCrewId)!;
for (const userId of additionalCrew.memberEmployeeIds) {
projectMembers.push({ id: id("project-member", projectMembers.length), projectId: project.id, userId, groupId: null, role: "monteur" });
}
}
if (projectIndex < 216) {
projectMembers.push({
id: id("project-member", projectMembers.length),
projectId: project.id,
userId: project.responsibleEmployeeId,
groupId: null,
role: "zustaendig",
});
}
const projectTaskCount = projectIndex < 73 ? 4 : 3;
for (let slot = 0; slot < projectTaskCount; slot += 1) {
const deadline = addDays(project.startDate ?? project.createdAt, 1 + slot * 2);
const done = new Date(deadline) < new Date(graph.referenceDate) && (projectIndex + slot) % 4 !== 0;
const assignedToCrew = slot === 1 || (slot === 2 && projectIndex % 3 === 0);
const createdAt = earlierDate(earlierDate(addDays(project.createdAt, slot), deadline), graph.referenceDate);
const completedAt = done ? addDays(deadline, 0, 16) : null;
const statusUpdatedAt =
done || (projectIndex + slot) % 3 !== 0
? (completedAt ?? createdAt)
: earlierDate(addDays(createdAt, 1 + ((projectIndex + slot) % 5)), graph.referenceDate);
tasks.push({
id: id("task", tasks.length),
projectId: project.id,
title: taskTemplates[project.projectType][slot]!,
description: `${project.projectNumber}: ${project.projectName}. Zuständigkeit und Ergebnis nachvollziehbar im Projekt dokumentieren.`,
status: done ? "done" : slot === 2 && projectIndex % 17 === 0 ? "blocked" : slot === 0 && projectIndex % 5 === 0 ? "in_progress" : "open",
priority: project.priority === "dringend" ? "urgent" : project.priority === "hoch" ? "high" : project.priority === "niedrig" ? "low" : "normal",
deadline,
assignedToUserId: assignedToCrew ? null : slot === 0 ? project.responsibleEmployeeId : crew.memberEmployeeIds[slot % crew.memberEmployeeIds.length]!,
assignedToGroupId: assignedToCrew ? crew.id : null,
completedAt,
createdAt,
updatedAt: laterDate(createdAt, statusUpdatedAt),
});
}
const activityCount = projectIndex < 46 ? 6 : 5;
for (let slot = 0; slot < activityCount; slot += 1) {
const [activityType, summaryText] = activityTemplates[slot]!;
const candidateCreatedAt = addDays(project.createdAt, slot * 2);
activities.push({
id: id("activity", activities.length),
projectId: project.id,
actorUserId: slot % 2 === 0 ? project.responsibleEmployeeId : project.projectManagerEmployeeId,
activityType,
createdAt: new Date(candidateCreatedAt) > new Date(graph.referenceDate) ? graph.referenceDate : candidateCreatedAt,
summaryText: `${summaryText}: ${project.projectNumber}`,
metadata: { projectNumber: project.projectNumber, projectType: project.projectType, seedNamespace: graph.namespace },
});
}
const calendarCount = projectIndex < 76 ? 2 : 1;
for (let slot = 0; slot < calendarCount; slot += 1) {
const userId = slot === 0 ? project.projectManagerEmployeeId : project.responsibleEmployeeId;
const calendarWindowStart = project.startDate ?? project.createdAt;
const calendarWindowDays = Math.max(
1,
Math.floor((new Date(project.deadline ?? graph.referenceDate).getTime() - new Date(calendarWindowStart).getTime()) / 86_400_000)
);
const dayOffset = Math.min(calendarWindowDays - 1, (projectIndex * 3 + slot) % calendarWindowDays);
const startsAt = addDays(calendarWindowStart, dayOffset, 9 + slot * 4);
const endsAt = new Date(new Date(startsAt).getTime() + (slot === 0 ? 90 : 45) * 60 * 1_000).toISOString();
const event = {
id: id("calendar", calendarEvents.length),
projectId: project.id,
userId,
title: slot === 0 ? `Baubesprechung · ${project.projectNumber}` : `Kundenabstimmung · ${project.projectNumber}`,
description: `${project.projectName}: Termin, nächste Schritte und offene Punkte abstimmen.`,
location: `${project.projectAddress.strasse} ${project.projectAddress.hausnummer}, ${project.projectAddress.plz} ${project.projectAddress.ort}`,
startsAt,
endsAt,
};
calendarEvents.push(event);
projectAppointments.push({
...event,
id: id("project-appointment", projectAppointments.length),
status: new Date(endsAt) < new Date(graph.referenceDate) ? "erledigt" : slot === 0 ? "bestaetigt" : "geplant",
});
}
}
const scheduleConflictPairs: Array<{ entryId: string; sourceEntryId: string }> = [];
const scheduledProjects = graph.projects.filter((project): project is SeedProject & { startDate: string } => Boolean(project.startDate));
for (const [scheduledProjectIndex, project] of scheduledProjects.entries()) {
const projectStartDate = project.startDate!;
const crew = crewById.get(project.crewIds[0]!)!;
const scheduleCount = scheduledProjectIndex < 157 ? 4 : 3;
const windowDays = Math.max(
1,
Math.floor((new Date(project.deadline ?? graph.referenceDate).getTime() - new Date(projectStartDate).getTime()) / 86_400_000)
);
const projectEntries: SeedScheduleEntry[] = [];
for (let slot = 0; slot < scheduleCount; slot += 1) {
const conflictSlot = scheduledProjectIndex < OPERATIONAL_COUNTS.scheduleConflicts && slot === 2;
const assignedUserId = conflictSlot ? crew.memberEmployeeIds[0] : crew.memberEmployeeIds[slot % crew.memberEmployeeIds.length]!;
const startAt = conflictSlot
? projectEntries[0]!.startAt
: addDays(projectStartDate, Math.min(windowDays - 1, Math.floor(slot / 2)), 9 + Math.floor(slot / 2) * 4);
const endAt = conflictSlot ? projectEntries[0]!.endAt : new Date(new Date(startAt).getTime() + 3 * 60 * 60 * 1_000).toISOString();
const past = new Date(endAt) < new Date(graph.referenceDate);
const entry: SeedScheduleEntry = {
id: id("schedule", scheduleEntries.length),
projectId: project.id,
assignedUserId,
title: `${project.projectNumber} · ${project.projectName}`,
startAt,
endAt,
status: past ? "done" : scheduledProjectIndex % 5 === 0 ? "confirmed" : "planned",
calendarEventId: null,
syncStatus: "pending",
};
projectEntries.push(entry);
scheduleEntries.push(entry);
if (conflictSlot) scheduleConflictPairs.push({ entryId: entry.id, sourceEntryId: projectEntries[0]!.id });
}
}
const bookingPages: SeedBookingPage[] = [
{
id: id("booking-page", 0),
slug: "heizung-bad-beratung",
title: "Heizungs- und Badberatung",
description: "Persönliche Erstberatung für Heizungstausch, Wärmepumpe und Badsanierung im Rhein-Main-Gebiet.",
durationMinutes: 45,
},
{
id: id("booking-page", 1),
slug: "wartung-bestandskunden",
title: "Wartung für Bestandskunden",
description: "Terminabstimmung für die regelmäßige Wartung bestehender Heizungs- und Sanitäranlagen.",
durationMinutes: 60,
},
{
id: id("booking-page", 2),
slug: "notdienst-rueckruf",
title: "Notdienst-Rückruf",
description: "Kurzer technischer Rückruf zur Einschätzung einer akuten Störung und zur Einsatzplanung.",
durationMinutes: 30,
},
];
const providers = graph.employees.filter(({ role }) => role === "Projektleiter/Bauleiter");
const bookingProviders = bookingPages.flatMap((page) =>
providers.map((employee, displayOrder) => ({
id: `${page.id}-provider-${String(displayOrder + 1).padStart(2, "0")}`,
bookingPageId: page.id,
providerUserId: employee.id,
displayOrder,
}))
);
const weekdays = ["monday", "tuesday", "wednesday", "thursday", "friday"] as const;
const availabilityRules = providers.flatMap((provider, providerIndex) =>
weekdays.map((dayOfWeek, weekdayIndex) => ({
id: id("availability-rule", providerIndex * weekdays.length + weekdayIndex),
providerUserId: provider.id,
dayOfWeek,
startTime: weekdayIndex === 4 ? "08:00" : providerIndex % 2 === 0 ? "08:30" : "09:00",
endTime: weekdayIndex === 4 ? "14:00" : providerIndex % 3 === 0 ? "16:30" : "17:00",
}))
);
const availabilityExceptions = providers.map((provider, index) => {
const customWindow = index % 3 === 1;
return {
id: id("availability-exception", index),
providerUserId: provider.id,
date: addDays(graph.referenceDate, 11 + index),
kind: customWindow ? ("custom_window" as const) : ("unavailable" as const),
startTime: customWindow ? "10:00" : null,
endTime: customWindow ? "14:00" : null,
reason: customWindow ? "Fortbildung am Vormittag" : index % 2 === 0 ? "Urlaub" : "Baustellenbegehung außer Haus",
};
});
const projectById = new Map(graph.projects.map((project) => [project.id, project]));
const providerIds = new Set(providers.map(({ id: providerId }) => providerId));
const bookingAppointments = calendarEvents
.filter(({ userId }) => providerIds.has(userId))
.filter(({ startsAt }) => {
const day = new Date(startsAt).getUTCDay();
return day >= 1 && day <= 5;
})
.slice(0, OPERATIONAL_COUNTS.bookingAppointments)
.map((event, index): SeedBookingAppointment => {
const project = projectById.get(event.projectId)!;
const primaryContact = project.contacts.find(({ primary }) => primary)?.contactId ?? project.contacts[0]!.contactId;
const page =
project.projectType === "reparatur_notdienst" ? bookingPages[2]! : project.projectType === "wartung_pruefung" ? bookingPages[1]! : bookingPages[0]!;
const cancelled = index % 17 === 0;
const endsAt = new Date(new Date(event.startsAt).getTime() + page.durationMinutes * 60_000).toISOString();
event.endsAt = endsAt;
const projectAppointment = projectAppointments.find(
(appointment) => appointment.projectId === event.projectId && appointment.userId === event.userId && appointment.startsAt === event.startsAt
);
if (projectAppointment) projectAppointment.endsAt = endsAt;
if (projectAppointment && cancelled) projectAppointment.status = "abgesagt";
return {
id: id("booking-appointment", index),
bookingPageId: page.id,
providerUserId: event.userId,
contactId: primaryContact,
projectId: project.id,
internalCalendarEventId: event.id,
startsAt: event.startsAt,
endsAt,
status: cancelled ? "cancelled" : new Date(endsAt) < new Date(graph.referenceDate) ? "held" : "scheduled",
customerName: contactDisplayName(graph, primaryContact),
customerEmail: contactEmail(graph, primaryContact),
customerPhone: contactPhone(graph, primaryContact),
request: `${project.projectName}: Terminwunsch zu ${project.description}`,
};
});
const calendarEventsByScheduleWindow = new Map<string, SeedCalendarEvent[]>();
for (const event of calendarEvents) {
const key = [event.projectId, event.userId, event.startsAt, event.endsAt].join("\u0000");
const matches = calendarEventsByScheduleWindow.get(key) ?? [];
matches.push(event);
calendarEventsByScheduleWindow.set(key, matches);
}
for (const entry of scheduleEntries) {
const key = [entry.projectId, entry.assignedUserId, entry.startAt, entry.endAt].join("\u0000");
const matches = calendarEventsByScheduleWindow.get(key) ?? [];
// A schedule row may only claim sync when one exact calendar counterpart
// exists. Similar-looking meetings are intentionally not guessed as links.
if (matches.length === 1) {
entry.calendarEventId = matches[0]!.id;
entry.syncStatus = "synced";
}
}
const taskWatchers = tasks.slice(0, OPERATIONAL_COUNTS.taskWatchers).map((task, index) => ({
id: id("task-watcher", index),
taskId: task.id,
userId: graph.employees[(index * 7) % graph.employees.length]!.id,
}));
const scheduleConflicts = scheduleConflictPairs.map((pair, index) => ({
id: id("schedule-conflict", index),
entryId: pair.entryId,
sourceEntryId: pair.sourceEntryId,
resolvedAt: index % 3 === 0 ? null : addDays(scheduleEntries.find(({ id: entryId }) => entryId === pair.entryId)!.startAt, -2),
}));
const billableProjects = graph.projects.filter((project) => project.pipeline === "auftrag" || project.stage === "gewonnen");
const invoiceProjects = Array.from({ length: OPERATIONAL_COUNTS.invoices }, (_, index) => billableProjects[index % billableProjects.length]!);
const invoices = invoiceProjects.map((project, index): SeedInvoice => {
const status: SeedInvoice["status"] =
project.stage === "storniert"
? "storniert"
: project.stage === "abgeschlossen"
? index % 7 === 0
? "gestellt"
: "bezahlt"
: project.stage === "abnahme" && index % 3 === 0
? "gestellt"
: "entwurf";
const date = earlierDate(addDays(project.createdAt, 3 + (index % 21)), graph.referenceDate);
const createdAt = earlierDate(addDays(project.createdAt, index % 3), date);
const lifecycleOffsetDays = status === "bezahlt" ? 7 + (index % 7) : status === "storniert" ? 2 + (index % 4) : status === "gestellt" ? 1 : 0;
return {
id: id("invoice", index),
projectId: project.id,
invoiceNumber: `RE-${new Date(date).getUTCFullYear()}-${String(70419 + index)}`,
amount: euro(project.orderVolume ?? project.potentialOrderValue, index % 4 === 0 ? 0.35 : 1),
status,
date,
dueAt: addDays(date, 14),
fileId: null,
createdAt,
updatedAt: laterDate(createdAt, earlierDate(addDays(date, lifecycleOffsetDays), graph.referenceDate)),
};
});
const checklistProjects = graph.projects
.filter((project) => project.pipeline === "auftrag" || project.stage === "gewonnen")
.slice(0, OPERATIONAL_COUNTS.checklists);
const checklists = checklistProjects.map(
(project, index): SeedChecklist => ({
id: id("checklist", index),
projectId: project.id,
title:
project.stage === "abnahme" || project.stage === "abgeschlossen"
? `Abnahmedokumentation ${project.projectNumber}`
: `Ausführungscheckliste ${project.projectNumber}`,
type: project.stage === "abnahme" ? "abnahme_doku" : index % 9 === 0 ? "maengel" : "generisch",
})
);
const checklistItemTitles = [
"Arbeitsbereich und Absperrungen vorbereitet",
"Material und Bauteile vollständig geprüft",
"Montage nach Herstellervorgaben ausgeführt",
"Messwerte und Druckprobe dokumentiert",
"Arbeitsbereich gereinigt und Kunde eingewiesen",
"Restpunkt mit Verantwortlichem und Termin erfasst",
] as const;
const checklistItems: SeedChecklistItem[] = [];
for (const [checklistIndex, checklist] of checklists.entries()) {
const project = graph.projects.find(({ id: projectId }) => projectId === checklist.projectId)!;
const projectCrew = crewById.get(project.crewIds[0]!)!;
const itemCount = checklistIndex < 48 ? 6 : 5;
for (let position = 0; position < itemCount; position += 1) {
checklistItems.push({
id: id("checklist-item", checklistItems.length),
checklistId: checklist.id,
title: checklistItemTitles[position]!,
status: checklistIndex % 4 === 0 && position > 2 ? "offen" : position === 5 && checklistIndex % 13 === 0 ? "entfaellt" : "erledigt",
defectClass: checklist.type === "maengel" && position === 3 ? "B" : null,
assignedToUserId: projectCrew.memberEmployeeIds[position % projectCrew.memberEmployeeIds.length]!,
dueAt: addDays(project.deadline ?? graph.referenceDate, position - 3),
position,
photoFileId: null,
});
}
}
const files: SeedFile[] = [];
const fileNames = ["Angebot", "Aufmaß", "Montageprotokoll", "Anlagenschema", "Messprotokoll", "Rechnung", "Abnahmeprotokoll"] as const;
for (const [projectIndex, project] of graph.projects.entries()) {
const fileCount = projectIndex < 380 ? 2 : 1;
for (let slot = 0; slot < fileCount; slot += 1) {
const ordinal = files.length;
const baseName = fileNames[(projectIndex + slot) % fileNames.length]!;
const descriptor = {
id: id("file", ordinal),
displayName: `${baseName}_${project.projectNumber}.pdf`,
notes: `Projektunterlage zu ${project.projectName}; dem Projekt ${project.projectNumber} zugeordnet.`,
};
files.push({
...buildSeedFileObjectMetadata(descriptor),
projectId: project.id,
assignedToUserId: project.projectManagerEmployeeId,
tags: [baseName],
linkRole: baseName.toLowerCase(),
createdAt: earlierDate(addDays(project.createdAt, 2 + slot), graph.referenceDate),
updatedAt: earlierDate(addDays(project.createdAt, 2 + slot), graph.referenceDate),
});
}
}
const invoiceFilesByProject = new Map<string, SeedFile[]>();
for (const file of files.filter(({ displayName }) => displayName.startsWith("Rechnung_"))) {
const projectFiles = invoiceFilesByProject.get(file.projectId) ?? [];
projectFiles.push(file);
invoiceFilesByProject.set(file.projectId, projectFiles);
}
for (const invoice of invoices) {
const projectFiles = invoiceFilesByProject.get(invoice.projectId);
invoice.fileId = projectFiles?.shift()?.id ?? null;
}
const acceptanceEligible = graph.projects.filter((project) => project.pipeline === "auftrag" && ["abnahme", "abgeschlossen"].includes(project.stage));
const defectAcceptanceProjects = acceptanceEligible
.filter((project) => checklists.find(({ projectId }) => projectId === project.id)?.type === "maengel")
.slice(0, 10);
const defectProjectIds = new Set(defectAcceptanceProjects.map(({ id: projectId }) => projectId));
const acceptanceProjects = [
...defectAcceptanceProjects,
...acceptanceEligible.filter((project) => !defectProjectIds.has(project.id)).slice(0, OPERATIONAL_COUNTS.acceptances - defectAcceptanceProjects.length),
];
const acceptances = acceptanceProjects.map((project, index): SeedAcceptance => {
const primaryContact = project.contacts.find(({ primary }) => primary)!.contactId;
const checklist = checklists.find(({ projectId }) => projectId === project.id);
const kind: SeedAcceptance["kind"] = index < defectAcceptanceProjects.length ? "with_defects" : "full";
const date = earlierDate(addDays(project.deadline ?? graph.referenceDate, index % 3), addDays(graph.referenceDate, -1));
const documentFileId = files.find((file) => file.projectId === project.id && file.displayName.startsWith("Abnahmeprotokoll_"))?.id ?? null;
const attendees = [...new Set([contactDisplayName(graph, primaryContact), contactDisplayName(graph, project.contacts.at(-1)!.contactId)])];
if (attendees.length < 2) attendees.push(employeeDisplayName(graph, project.projectManagerEmployeeId));
return {
id: id("acceptance", index),
projectId: project.id,
checklistId: checklist?.id ?? null,
creatorUserId: project.projectManagerEmployeeId,
date,
kind,
attendees: attendees.slice(0, 2),
remarks:
kind === "with_defects"
? "Abnahme mit dokumentierten Restpunkten und verbindlichem Nachtermin."
: "Leistung gemeinsam geprüft, Anlage erläutert und ohne Vorbehalt abgenommen.",
customerEmail: contactEmail(graph, primaryContact),
documentFileId,
createdAt: date,
updatedAt: addDays(date, 0, 15),
};
});
const acceptanceSignatures = acceptances.flatMap((acceptance, index) => {
const project = graph.projects.find(({ id: projectId }) => projectId === acceptance.projectId)!;
const crew = crewById.get(project.crewIds[0]!)!;
return [
{
id: id("acceptance-signature", index * 2),
acceptanceId: acceptance.id,
signerName: acceptance.attendees[0]!,
signerRole: "kunde" as const,
signedAt: addDays(acceptance.date, 0, 15),
},
{
id: id("acceptance-signature", index * 2 + 1),
acceptanceId: acceptance.id,
signerName: employeeDisplayName(graph, crew.memberEmployeeIds[0]!),
signerRole: "monteur" as const,
signedAt: addDays(acceptance.date, 0, 15),
},
];
});
const signatureProjects = graph.projects
.filter(
(project) =>
project.pipeline === "sales" &&
["angebot", "gewonnen"].includes(project.stage) &&
files.some((file) => file.projectId === project.id && file.displayName.startsWith("Angebot_"))
)
.slice(0, OPERATIONAL_COUNTS.signatureDocuments);
const signatureDocuments = signatureProjects.map((project, index): SeedSignatureDocument => {
const primaryContact = project.contacts.find(({ primary }) => primary)!.contactId;
const status: SeedSignatureDocument["status"] = index % 4 === 0 ? "sent" : index % 4 === 1 ? "viewed" : "signed";
const sentAt = addDays(project.createdAt, 4 + (index % 8));
const completedAt = status === "signed" ? addDays(sentAt, 2 + (index % 5)) : null;
return {
id: id("signature-document", index),
projectId: project.id,
sourceFileId: files.find((file) => file.projectId === project.id && file.displayName.startsWith("Angebot_"))!.id,
creatorUserId: project.responsibleEmployeeId,
status,
title: `Angebot ${project.projectNumber} zur elektronischen Freigabe`,
sentAt,
completedAt,
signerContactId: primaryContact,
signerEmail: contactEmail(graph, primaryContact),
signerName: contactDisplayName(graph, primaryContact),
createdAt: sentAt,
updatedAt: completedAt ?? (status === "viewed" ? new Date(new Date(sentAt).getTime() + 3_600_000).toISOString() : sentAt),
};
});
const signatureSigners = signatureDocuments.map((document, index) => ({
id: id("signature-signer", index),
documentId: document.id,
contactId: document.signerContactId,
email: document.signerEmail,
name: document.signerName,
status: document.status,
signedAt: document.completedAt,
}));
const operational: DemoProOperationalGraph = {
projectContacts,
projectMembers,
tasks,
taskWatchers,
activities,
scheduleEntries,
scheduleConflicts,
calendarEvents,
projectAppointments,
bookingPages,
bookingProviders,
availabilityRules,
availabilityExceptions,
bookingAppointments,
invoices,
checklists,
checklistItems,
files,
acceptances,
acceptanceSignatures,
signatureDocuments,
signatureSigners,
};
validateOperationalGraph(operational, graph.referenceDate);
return operational;
}
export function validateOperationalGraph(graph: DemoProOperationalGraph, referenceDate: string): void {
for (const [key, expected] of Object.entries(OPERATIONAL_COUNTS)) {
const actual = graph[key as keyof DemoProOperationalGraph].length;
if (actual !== expected) throw new Error(`Operational seed ${key}: expected ${expected}, received ${actual}.`);
}
if (graph.tasks.some((task) => Number(Boolean(task.assignedToUserId)) + Number(Boolean(task.assignedToGroupId)) !== 1)) {
throw new Error("Every operational task must have exactly one assignee.");
}
if (new Set(graph.scheduleEntries.map(({ id: entryId }) => entryId)).size !== graph.scheduleEntries.length) {
throw new Error("Operational schedule IDs must be unique.");
}
const reference = new Date(referenceDate);
const invalidTask = graph.tasks.find(
(task) =>
new Date(task.createdAt) > new Date(task.updatedAt) ||
new Date(task.updatedAt) > reference ||
(task.completedAt !== null && (new Date(task.completedAt) < new Date(task.createdAt) || new Date(task.completedAt) > reference)) ||
(task.status === "done") !== (task.completedAt !== null)
);
if (invalidTask) throw new Error(`Operational task ${invalidTask.id} timestamps violate the task lifecycle.`);
if (
graph.invoices.some(
(invoice) =>
new Date(invoice.createdAt) > new Date(invoice.date) ||
new Date(invoice.date) > new Date(invoice.updatedAt) ||
new Date(invoice.updatedAt) > reference ||
new Date(invoice.date) > new Date(invoice.dueAt)
)
) {
throw new Error("Operational invoice timestamps violate the invoice lifecycle.");
}
if (graph.files.some((file) => new Date(file.createdAt) > new Date(file.updatedAt) || new Date(file.updatedAt) > reference)) {
throw new Error("Operational file timestamps violate the file lifecycle.");
}
if (
graph.acceptances.some(
(acceptance) =>
new Date(acceptance.date) > new Date(acceptance.createdAt) ||
new Date(acceptance.createdAt) > new Date(acceptance.updatedAt) ||
new Date(acceptance.updatedAt) > reference
)
) {
throw new Error("Operational acceptance timestamps violate the acceptance lifecycle.");
}
if (
graph.signatureDocuments.some(
(document) =>
document.createdAt !== document.sentAt ||
new Date(document.createdAt) > new Date(document.updatedAt) ||
new Date(document.updatedAt) > reference ||
(document.status === "signed") !== (document.completedAt !== null) ||
(document.completedAt !== null && document.updatedAt !== document.completedAt)
)
) {
throw new Error("Operational signature timestamps violate the signature lifecycle.");
}
const calendarEventsById = new Map(graph.calendarEvents.map((event) => [event.id, event]));
if (
graph.scheduleEntries.some((entry) => {
if (entry.calendarEventId === null) return entry.syncStatus !== "pending";
const event = calendarEventsById.get(entry.calendarEventId);
return (
entry.syncStatus !== "synced" ||
!event ||
event.projectId !== entry.projectId ||
event.userId !== entry.assignedUserId ||
event.startsAt !== entry.startAt ||
event.endsAt !== entry.endAt
);
})
) {
throw new Error("Operational schedule entries claim calendar sync without an exact matching event.");
}
const filesById = new Map(graph.files.map((file) => [file.id, file]));
const linkedInvoiceFileIds = graph.invoices.flatMap(({ fileId }) => (fileId ? [fileId] : []));
if (
new Set(linkedInvoiceFileIds).size !== linkedInvoiceFileIds.length ||
graph.invoices.some((invoice) => {
if (invoice.fileId === null) return false;
const file = filesById.get(invoice.fileId);
return !file || file.projectId !== invoice.projectId || !file.displayName.startsWith("Rechnung_");
})
) {
throw new Error("Operational invoices contain ambiguous or semantically invalid file links.");
}
if (graph.checklistItems.some(({ photoFileId }) => photoFileId !== null)) {
throw new Error("Operational checklist items cannot use generated PDF files as photos.");
}
if (
graph.acceptances.some((acceptance) => {
if (acceptance.documentFileId === null) return false;
const file = filesById.get(acceptance.documentFileId);
return !file || file.projectId !== acceptance.projectId || !file.displayName.startsWith("Abnahmeprotokoll_");
})
) {
throw new Error("Operational acceptances contain semantically invalid document links.");
}
}