Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/utils/services/.server/akP20OnboardingService.ts
T

393 lines
13 KiB
TypeScript

import { CatalogError, foundationErrors } from "@hivegrid/foundation";
import { getRlsExecutionContext, runWithIsolatedUserRlsContext, runWithRlsContext } from "@hivegrid/db/rls-context.server";
import {
hasExactShkFirstSteps,
SHK_FIRST_STEPS,
SHK_FIRST_STEPS_CHECKLIST_CODE,
SHK_FIRST_STEPS_CHECKLIST_ID,
} from "~/domain/tenant-bootstrap/tenantBootstrap.constants";
import { db } from "~/utils/db.server";
import { ensureDefaultSalesPipeline } from "~/utils/integrations/projects/projectService.server";
const SHK_DEMO_TEMPLATE_CODE = "shk-demo-v1";
const checklistSteps = [
{ ...SHK_FIRST_STEPS[0], titleKey: "onboarding.firstSteps.profile", href: "settings/profile" },
{ ...SHK_FIRST_STEPS[1], titleKey: "onboarding.firstSteps.contacts", href: "contacts" },
{ ...SHK_FIRST_STEPS[2], titleKey: "onboarding.firstSteps.projects", href: "projects" },
{ ...SHK_FIRST_STEPS[3], titleKey: "onboarding.firstSteps.billing", href: "settings/billing" },
] as const;
const TEAM_CHECKLIST_ITEM = {
id: "shk-first-steps-team-detection-v1",
block: "team",
titleKey: "onboarding.firstSteps.team",
href: "settings/team/members/new",
canComplete: false,
} as const;
type DemoEntityMap = Record<string, string[]>;
type FirstStepsBlock = (typeof checklistSteps)[number]["block"] | typeof TEAM_CHECKLIST_ITEM.block;
type FirstStepsCatalogStep = { id: string; order: number; block: string };
type ResolvedFirstStepsSession = {
id: string;
status: string;
stepIds: string[];
};
export async function getFirstStepsChecklist(input: { tenantId: string; userId: string }) {
return await withChecklistRlsContext(input, () => getFirstStepsChecklistInContext(input));
}
async function getFirstStepsChecklistInContext(input: { tenantId: string; userId: string }) {
const session = await findFirstStepsSession(input);
if (!session) {
return emptyFirstStepsChecklist();
}
const rows = await db.onboardingSessionStep.findMany({
where: {
onboardingSessionId: session.id,
stepId: { in: session.stepIds },
},
include: { step: true },
orderBy: { step: { order: "asc" } },
});
if (rows.length === 0) {
return emptyFirstStepsChecklist();
}
const autoCompletedBlocks = await detectFirstStepsCompletion(input);
const dismissed = session.status === "dismissed";
const items: Array<{
id: string;
block: string;
titleKey: string;
href: string;
completed: boolean;
hidden: boolean;
canComplete?: boolean;
}> = rows.flatMap((row) => {
const config = checklistSteps.find((step) => step.order === row.step.order && step.block === row.step.block);
if (!config) return [];
const completed = Boolean(row.completedAt) || autoCompletedBlocks.has(row.step.block as FirstStepsBlock);
return [
{
id: row.id,
block: row.step.block,
titleKey: config.titleKey,
href: config.href,
completed,
hidden: dismissed,
},
];
});
if (items.length !== rows.length) return emptyFirstStepsChecklist();
items.splice(1, 0, {
...TEAM_CHECKLIST_ITEM,
completed: autoCompletedBlocks.has(TEAM_CHECKLIST_ITEM.block),
hidden: dismissed,
});
const completedCount = items.filter((item) => item.completed).length;
return {
id: session.id,
status: !dismissed && items.length > 0 && completedCount === items.length ? "completed" : session.status,
dismissed,
completedCount,
totalCount: items.length,
percentComplete: items.length > 0 ? Math.round((completedCount / items.length) * 100) : 0,
items,
};
}
function emptyFirstStepsChecklist() {
return {
id: "",
status: "active",
dismissed: false,
completedCount: 0,
totalCount: 0,
percentComplete: 0,
items: [],
};
}
async function detectFirstStepsCompletion(input: { tenantId: string; userId: string }): Promise<Set<FirstStepsBlock>> {
const now = new Date();
const [user, memberCount, pendingInvitationCount, contactCount, projectCount, subscription] = await Promise.all([
db.user.findUnique({ where: { id: input.userId }, select: { firstName: true, lastName: true, email: true } }),
db.tenantUser.count({ where: { tenantId: input.tenantId } }),
db.tenantUserInvitation.count({
where: {
tenantId: input.tenantId,
pending: true,
status: "pending",
revokedAt: null,
OR: [{ expiresAt: null }, { expiresAt: { gt: now } }],
},
}),
db.kontakt.count({ where: { tenantId: input.tenantId, isDemoData: false } }),
db.projekt.count({ where: { tenantId: input.tenantId, isDemoData: false } }),
db.tenantSubscription.findUnique({ where: { tenantId: input.tenantId }, select: { status: true } }),
]);
const completed = new Set<FirstStepsBlock>();
if (user?.firstName && user.lastName && user.email) completed.add("profile");
if (memberCount > 1 || pendingInvitationCount > 0) completed.add("team");
if (contactCount > 0) completed.add("contacts");
if (projectCount > 0) completed.add("projects");
if (subscription?.status === "trial" || subscription?.status === "active") completed.add("billing");
return completed;
}
export async function updateFirstStepsChecklist(input: {
tenantId: string;
userId: string;
sessionStepId?: string | null;
action: "complete" | "hide" | "show";
}) {
return await withChecklistRlsContext(input, () => updateFirstStepsChecklistInContext(input));
}
async function updateFirstStepsChecklistInContext(input: {
tenantId: string;
userId: string;
sessionStepId?: string | null;
action: "complete" | "hide" | "show";
}) {
const session = await findFirstStepsSession(input);
if (!session) {
throw new CatalogError(foundationErrors.notFound, { resource: "shk-first-steps-session" });
}
if (input.action === "hide") {
return await db.onboardingSession.update({
where: { id: session.id },
data: { status: "dismissed", dismissedAt: new Date() },
});
}
if (input.action === "show") {
return await db.onboardingSession.update({
where: { id: session.id },
data: { status: "active", dismissedAt: null },
});
}
if (!input.sessionStepId) {
throw new CatalogError(foundationErrors.notFound, { resource: "shk-first-steps-step" });
}
const result = await db.onboardingSessionStep.updateMany({
where: {
id: input.sessionStepId,
onboardingSessionId: session.id,
stepId: { in: session.stepIds },
},
data: { completedAt: new Date() },
});
if (result.count !== 1) {
throw new CatalogError(foundationErrors.notFound, { resource: "shk-first-steps-step" });
}
return result;
}
async function findFirstStepsSession(input: { tenantId: string; userId: string }): Promise<ResolvedFirstStepsSession | null> {
const canonicalCatalog = await findCanonicalFirstStepsCatalog();
if (canonicalCatalog) {
const canonicalSession = await db.onboardingSession.findUnique({
where: {
onboardingId_userId_tenantId: {
onboardingId: canonicalCatalog.id,
userId: input.userId,
tenantId: input.tenantId,
},
},
});
if (canonicalSession) {
return {
id: canonicalSession.id,
status: canonicalSession.status,
stepIds: SHK_FIRST_STEPS.map((step) => step.id),
};
}
}
const legacySession = await db.onboardingSession.findFirst({
where: {
userId: input.userId,
tenantId: input.tenantId,
onboardingId: { not: SHK_FIRST_STEPS_CHECKLIST_ID },
onboarding: { title: SHK_FIRST_STEPS_CHECKLIST_CODE },
},
select: {
id: true,
status: true,
onboarding: {
select: {
steps: { select: { id: true, order: true, block: true } },
},
},
},
orderBy: { createdAt: "asc" },
});
if (!legacySession || !hasExactLegacyFirstSteps(legacySession.onboarding.steps)) {
return null;
}
return {
id: legacySession.id,
status: legacySession.status,
stepIds: legacySession.onboarding.steps.map((step) => step.id),
};
}
function hasExactLegacyFirstSteps(steps: ReadonlyArray<FirstStepsCatalogStep>): boolean {
return (
steps.length === checklistSteps.length &&
checklistSteps.every((expected) => steps.some((actual) => actual.order === expected.order && actual.block === expected.block))
);
}
async function findCanonicalFirstStepsCatalog() {
const onboarding = await db.onboarding.findUnique({
where: { id: SHK_FIRST_STEPS_CHECKLIST_ID },
select: {
id: true,
title: true,
type: true,
realtime: true,
active: true,
canBeDismissed: true,
height: true,
steps: { select: { id: true, order: true, block: true } },
},
});
if (
!onboarding ||
onboarding.title !== SHK_FIRST_STEPS_CHECKLIST_CODE ||
onboarding.type !== "page" ||
onboarding.realtime !== false ||
!onboarding.active ||
onboarding.canBeDismissed !== true ||
onboarding.height !== null ||
!hasExactShkFirstSteps(onboarding.steps)
) {
return null;
}
return onboarding;
}
function withChecklistRlsContext<T>(input: { tenantId: string; userId: string }, operation: () => T): T {
const current = getRlsExecutionContext();
if (current?.userId && current.userId !== input.userId) {
throw new CatalogError(foundationErrors.notFound, { resource: "shk-first-steps-session" });
}
const bindTarget = () => runWithRlsContext({ tenantId: input.tenantId, userId: input.userId }, operation);
if (current?.userId === input.userId && (current.transaction || (current.tenantId && current.tenantId !== input.tenantId))) {
return runWithIsolatedUserRlsContext(input.userId, bindTarget);
}
return bindTarget();
}
export async function getDemoDataStatus(tenantId: string) {
return await db.onboardingDemoProvisioning.findFirst({
where: { tenantId, templateCode: SHK_DEMO_TEMPLATE_CODE, status: "active", deletedAt: null },
orderBy: { createdAt: "desc" },
});
}
export async function provisionShkDemoData(input: { tenantId: string; userId: string }) {
const existing = await getDemoDataStatus(input.tenantId);
if (existing) {
return existing;
}
const { pipeline, firstOpenStage } = await ensureDefaultSalesPipeline({ tenantId: input.tenantId, userId: input.userId });
const contacts = await Promise.all(
["Muster GmbH", "Solar Schmidt", "Elektro Weber", "Hausverwaltung Nord", "Ada Lovelace"].map((name, index) =>
db.kontakt.create({
data: {
tenantId: input.tenantId,
createdByUserId: input.userId,
kontaktTyp: index === 4 ? "privatperson" : "organisation",
kontaktStatus: index < 2 ? "kunde" : "kontakt",
orgName: index === 4 ? null : name,
vorname: index === 4 ? "Ada" : null,
nachname: index === 4 ? "Lovelace" : null,
primaerEmail: `demo-${index + 1}@example.invalid`,
isDemoData: true,
zustaendigerUserId: input.userId,
},
})
)
);
const projects = await Promise.all(
["Heizungstausch Musterstraße", "PV-Angebot Nord", "Wartung Bestandshaus"].map((name, index) =>
db.projekt.create({
data: {
tenantId: input.tenantId,
createdByUserId: input.userId,
projektNummer: `DEMO-${String(index + 1).padStart(4, "0")}`,
projektname: name,
projekttyp: index === 2 ? "auftrag" : "deal",
quelle: "demo",
pipelineId: pipeline.id,
stageId: firstOpenStage.id,
zustaendigePersonId: input.userId,
isDemoData: true,
},
})
)
);
const tasks = await Promise.all(
["Demo-Kontakt prüfen", "Demo-Projekt kalkulieren", "Demo-Angebot versenden"].map((title, index) =>
db.task.create({
data: {
tenantId: input.tenantId,
createdByUserId: input.userId,
assignedToUserId: input.userId,
title,
linkedEntityType: "project",
linkedEntityId: projects[index % projects.length].id,
isDemoData: true,
},
})
)
);
const entitiesCreated: DemoEntityMap = {
kontakt: contacts.map((item) => item.id),
projekt: projects.map((item) => item.id),
task: tasks.map((item) => item.id),
};
return await db.onboardingDemoProvisioning.create({
data: {
tenantId: input.tenantId,
createdByUserId: input.userId,
templateCode: SHK_DEMO_TEMPLATE_CODE,
entitiesCreated,
removableUntil: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
},
});
}
export async function deleteShkDemoData(input: { tenantId: string; provisioningId: string }) {
const provisioning = await db.onboardingDemoProvisioning.findFirst({
where: { id: input.provisioningId, tenantId: input.tenantId, status: "active", deletedAt: null },
});
if (!provisioning) {
return null;
}
const entities = provisioning.entitiesCreated as DemoEntityMap;
await db.$transaction([
db.task.deleteMany({ where: { tenantId: input.tenantId, id: { in: entities.task ?? [] }, isDemoData: true } }),
db.projekt.deleteMany({ where: { tenantId: input.tenantId, id: { in: entities.projekt ?? [] }, isDemoData: true } }),
db.kontakt.deleteMany({ where: { tenantId: input.tenantId, id: { in: entities.kontakt ?? [] }, isDemoData: true } }),
db.onboardingDemoProvisioning.update({
where: { id: provisioning.id },
data: { status: "deleted", deletedAt: new Date() },
}),
]);
return provisioning;
}