import type { AdminBooking, Prisma, PrismaClient, } from "../generated/prisma/client/client.js"; import { selectAdminBookingHost, type AdminBookingRoundRobinCandidate, } from "./admin-booking-round-robin.js"; import { writeAdminSalesAudit } from "./admin-sales-core.server.js"; import { publishOutboxEvent } from "./outbox.js"; const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u; const MAX_NAME_LENGTH = 120; const MAX_ANSWER_LENGTH = 4_000; const DAY_MS = 86_400_000; export type ReserveAdminBookingInput = { readonly bookingPageId: string; readonly startsAt: Date; readonly endsAt: Date; readonly bookerTimeZone: string; readonly bookerFirstName: string; readonly bookerLastName: string; readonly bookerEmail: string; readonly bookerLocale?: string | null; readonly intakeAnswers: Readonly>; readonly availableHostAdminUserIds: readonly string[]; readonly manualHostAdminUserId?: string | null; readonly dealId?: string | null; readonly idempotencyKey: string; readonly manageTokenExpiresAt: Date; readonly reschedule?: { readonly previousBookingId: string; readonly manageTokenVersion: number; readonly manageTokenExpiresAfter: Date; readonly manageNonceHash: string; }; }; export type ReservedAdminBooking = { readonly booking: AdminBooking; readonly selectedHostAdminUserId: string; readonly contactCreated: boolean; }; export type AdminBookingRepository = { reserve(input: ReserveAdminBookingInput): Promise; }; export function createAdminBookingService(input: { readonly repository: AdminBookingRepository; }) { return { async reserve(command: ReserveAdminBookingInput) { return input.repository.reserve(normalizeReservation(command)); }, }; } type AdminBookingPrismaClient = Pick< PrismaClient, | "$transaction" | "adminBooking" | "adminBookingPage" | "adminUser" | "adminAvailabilityOverride" | "adminBookingAssignment" | "adminContact" | "adminDeal" >; export function createPrismaAdminBookingRepository( client: AdminBookingPrismaClient, dependencies: { readonly now?: () => Date } = {} ): AdminBookingRepository { const now = dependencies.now ?? (() => new Date()); return { reserve: (command) => client.$transaction( async (tx) => { const existing = await tx.adminBooking.findUnique({ where: { idempotencyKey: command.idempotencyKey }, include: { assignment: true }, }); if (existing?.assignment) { return { booking: existing, selectedHostAdminUserId: existing.assignment.selectedHostAdminUserId, contactCreated: false, }; } const page = await tx.adminBookingPage.findFirst({ where: { id: command.bookingPageId, published: true, archivedAt: null, meetingType: { active: true, archivedAt: null }, }, include: { meetingType: true }, }); if (!page) throw new AdminBookingError("page_unavailable"); assertPageRules(page, command, now()); const previousBooking = command.reschedule ? await tx.adminBooking.findFirst({ where: { id: command.reschedule.previousBookingId, bookingPageId: page.id, status: { in: [ "reserved", "confirmed", "provider_sync_failed", ], }, manageTokenVersion: command.reschedule.manageTokenVersion, manageTokenExpiresAt: { gt: command.reschedule.manageTokenExpiresAfter, }, OR: [ { lastManageNonceHash: null }, { lastManageNonceHash: { not: command.reschedule.manageNonceHash, }, }, ], }, }) : null; if (command.reschedule && !previousBooking) { throw new AdminBookingError("booking_unavailable"); } const candidatePool = await loadRoundRobinCandidates(tx, { hostAdminUserIds: page.meetingType.hostAdminUserIds, startsAt: command.startsAt, endsAt: command.endsAt, availableHostAdminUserIds: command.availableHostAdminUserIds, }); const selection = selectAdminBookingHost({ candidates: candidatePool.candidates, availableHostAdminUserIds: candidatePool.availableHostAdminUserIds, manualHostAdminUserId: command.manualHostAdminUserId, }); const selectedHostAdminUserId = selection.selectedHostAdminUserId; const slotReservationKey = [ selectedHostAdminUserId, command.startsAt.toISOString(), command.endsAt.toISOString(), ].join(":"); const [contactMatch, conflictingBooking, dailyCount] = await Promise.all([ resolveBookingContact(tx, command), tx.adminBooking.findFirst({ where: { adminUserId: selectedHostAdminUserId, status: { in: ["reserved", "confirmed"], }, startsAt: { lt: command.endsAt }, endsAt: { gt: command.startsAt }, }, select: { id: true }, }), tx.adminBooking.count({ where: { bookingPageId: page.id, participants: { some: { email: command.bookerEmail }, }, createdAt: { gte: startOfUtcDay(now()), lt: endOfUtcDay(now()), }, status: { not: "cancelled" }, }, }), ]); if (conflictingBooking) { throw new AdminBookingError("slot_taken"); } if (dailyCount >= page.maxBookingsPerEmailPerDay) { throw new AdminBookingError("rate_limited"); } if (command.dealId) { await assertDealLink(tx, command.dealId, contactMatch.contact.id); } if ( previousBooking && previousBooking.contactId !== contactMatch.contact.id ) { throw new AdminBookingError("booking_unavailable"); } const booking = await tx.adminBooking.create({ data: { adminUserId: selectedHostAdminUserId, bookingPageId: page.id, meetingTypeId: page.meetingType.id, contactId: contactMatch.contact.id, dealId: command.dealId, startsAt: command.startsAt, endsAt: command.endsAt, bookerTimeZone: command.bookerTimeZone, status: "reserved", idempotencyKey: command.idempotencyKey, slotReservationKey, intakeAnswers: command.intakeAnswers as Prisma.InputJsonValue, manageTokenExpiresAt: command.manageTokenExpiresAt, rescheduledFromId: previousBooking?.id, participants: { create: { adminUserId: selectedHostAdminUserId, email: command.bookerEmail, name: `${command.bookerFirstName} ${command.bookerLastName}`, locale: command.bookerLocale, timeZone: command.bookerTimeZone, isOrganizer: false, }, }, assignment: { create: { adminUserId: selectedHostAdminUserId, kind: command.manualHostAdminUserId ? "manual" : "round_robin", selectedHostAdminUserId, overriddenByAdminUserId: command.manualHostAdminUserId ? page.createdByAdminUserId : null, eligibleHostAdminUserIds: [ ...selection.eligibleHostAdminUserIds, ], excludedHosts: selection.excludedHosts as unknown as Prisma.InputJsonValue, loadSnapshot: selection.loadSnapshot as unknown as Prisma.InputJsonValue, selectionReason: selection.selectionReason, }, }, reminders: { create: page.meetingType.reminderOffsetsMinutes .filter( (offset) => command.startsAt.getTime() - offset * 60_000 > now().getTime() ) .map((offset) => ({ adminUserId: selectedHostAdminUserId, offsetMinutes: offset, scheduledFor: new Date( command.startsAt.getTime() - offset * 60_000 ), idempotencyKey: `${command.idempotencyKey}:reminder:${offset}`, })), }, }, }); if (previousBooking && command.reschedule) { await tx.adminBooking.update({ where: { id: previousBooking.id }, data: { status: "rescheduled", manageTokenVersion: { increment: 1 }, lastManageNonceHash: command.reschedule.manageNonceHash, reminders: { updateMany: { where: { status: { in: ["pending", "processing"] }, }, data: { status: "cancelled" }, }, }, }, }); } await tx.adminActivity.create({ data: { type: "meeting", actorAdminUserId: page.createdByAdminUserId, companyId: contactMatch.contact.companyId, contactId: contactMatch.contact.id, dealId: command.dealId, bookingId: booking.id, summary: previousBooking ? `${page.meetingType.name} umgebucht` : `${page.meetingType.name} gebucht`, payload: { startsAt: command.startsAt.toISOString(), endsAt: command.endsAt.toISOString(), hostAdminUserId: selectedHostAdminUserId, source: "public_booking_page", ...(previousBooking ? { previousBookingId: previousBooking.id, replacementBookingId: booking.id, sequenceStopEvent: "booking_rescheduled", } : {}), }, }, }); await publishOutboxEvent(tx, { tenantId: null, type: previousBooking ? "booking.provider.reschedule" : "booking.provider.create", dispatchKey: previousBooking ? `admin-booking:${previousBooking.id}:provider-reschedule:${booking.id}` : `admin-booking:${booking.id}:provider-create`, payload: previousBooking ? { previousBookingId: previousBooking.id, replacementBookingId: booking.id, adminUserId: selectedHostAdminUserId, } : { bookingId: booking.id, adminUserId: selectedHostAdminUserId, }, }); await writeAdminSalesAudit(tx, { actor: { adminUserId: page.createdByAdminUserId, reason: "Öffentliche Terminbuchung", }, action: previousBooking ? "admin.sales.booking.rescheduled" : "admin.sales.booking.reserved", targetType: "AdminBooking", targetId: booking.id, after: { contactId: contactMatch.contact.id, dealId: command.dealId, startsAt: command.startsAt.toISOString(), selectedHostAdminUserId, assignmentKind: command.manualHostAdminUserId ? "manual" : "round_robin", ...(previousBooking ? { previousBookingId: previousBooking.id } : {}), }, }); return { booking, selectedHostAdminUserId, contactCreated: contactMatch.created, }; }, { isolationLevel: "Serializable" } ), }; } async function loadRoundRobinCandidates( tx: Prisma.TransactionClient, input: { readonly hostAdminUserIds: readonly string[]; readonly startsAt: Date; readonly endsAt: Date; readonly availableHostAdminUserIds: readonly string[]; } ): Promise<{ readonly candidates: readonly AdminBookingRoundRobinCandidate[]; readonly availableHostAdminUserIds: readonly string[]; }> { const date = new Date( Date.UTC( input.startsAt.getUTCFullYear(), input.startsAt.getUTCMonth(), input.startsAt.getUTCDate() ) ); const [users, absences, activeLoads, lastAssignments, conflicts] = await Promise.all([ tx.adminUser.findMany({ where: { id: { in: [...input.hostAdminUserIds] }, status: "active", roles: { some: { role: { active: true, permissions: { some: { permission: { name: "admin_sales.booking.manage", }, }, }, }, }, }, }, select: { id: true }, }), tx.adminAvailabilityOverride.findMany({ where: { adminUserId: { in: [...input.hostAdminUserIds] }, date, kind: "unavailable", archivedAt: null, }, select: { adminUserId: true }, }), tx.adminBooking.groupBy({ by: ["adminUserId"], where: { adminUserId: { in: [...input.hostAdminUserIds] }, status: { in: ["reserved", "confirmed"] }, startsAt: { gte: input.startsAt }, }, _count: { _all: true }, }), tx.adminBookingAssignment.groupBy({ by: ["selectedHostAdminUserId"], where: { selectedHostAdminUserId: { in: [...input.hostAdminUserIds], }, }, _max: { createdAt: true }, }), tx.adminBooking.findMany({ where: { adminUserId: { in: [...input.hostAdminUserIds] }, status: { in: ["reserved", "confirmed"] }, startsAt: { lt: input.endsAt }, endsAt: { gt: input.startsAt }, }, select: { adminUserId: true }, }), ]); const eligible = new Set(users.map((user) => user.id)); const absent = new Set(absences.map((item) => item.adminUserId)); const conflicted = new Set( conflicts.map((item) => item.adminUserId) ); const available = new Set( input.availableHostAdminUserIds.filter( (adminUserId) => !conflicted.has(adminUserId) ) ); const loadByHost = new Map( activeLoads.map((item) => [ item.adminUserId, item._count._all, ]) ); const lastByHost = new Map( lastAssignments.map((item) => [ item.selectedHostAdminUserId, item._max.createdAt, ]) ); return { candidates: input.hostAdminUserIds.map((adminUserId) => ({ adminUserId, eligible: eligible.has(adminUserId), absent: absent.has(adminUserId), activeBookingCount: loadByHost.get(adminUserId) ?? 0, lastAssignedAt: lastByHost.get(adminUserId) ?? null, })), availableHostAdminUserIds: [...available], }; } async function resolveBookingContact( tx: Prisma.TransactionClient, command: ReserveAdminBookingInput ): Promise<{ readonly contact: { readonly id: string; readonly companyId: string | null; }; readonly created: boolean; }> { const matches = await tx.adminContact.findMany({ where: { normalizedEmail: command.bookerEmail, archivedAt: null, }, select: { id: true, companyId: true }, take: 2, }); if (matches.length > 1) { throw new AdminBookingError("contact_ambiguous"); } if (matches[0]) return { contact: matches[0], created: false }; const contact = await tx.adminContact.create({ data: { firstName: command.bookerFirstName, lastName: command.bookerLastName, email: command.bookerEmail, normalizedEmail: command.bookerEmail, locale: command.bookerLocale, timeZone: command.bookerTimeZone, }, select: { id: true, companyId: true }, }); return { contact, created: true }; } async function assertDealLink( tx: Prisma.TransactionClient, dealId: string, contactId: string ): Promise { const deal = await tx.adminDeal.findFirst({ where: { id: dealId, status: "open", archivedAt: null, contacts: { some: { contactId } }, }, select: { id: true }, }); if (!deal) throw new AdminBookingError("deal_unavailable"); } function assertPageRules( page: { readonly allowedEmailDomains: readonly string[]; readonly meetingType: { readonly durationMinutes: number }; }, command: ReserveAdminBookingInput, now: Date ): void { if (command.startsAt <= now || command.endsAt <= command.startsAt) { throw new AdminBookingError("invalid_slot"); } if ( command.endsAt.getTime() - command.startsAt.getTime() !== page.meetingType.durationMinutes * 60_000 ) { throw new AdminBookingError("invalid_slot"); } const domain = command.bookerEmail.split("@")[1]; if ( page.allowedEmailDomains.length > 0 && !page.allowedEmailDomains.includes(domain) ) { throw new AdminBookingError("email_domain_denied"); } } function normalizeReservation( command: ReserveAdminBookingInput ): ReserveAdminBookingInput { const bookerEmail = command.bookerEmail.trim().toLowerCase(); if (!EMAIL_PATTERN.test(bookerEmail)) { throw new AdminBookingError("invalid_email"); } const firstName = normalizeName(command.bookerFirstName); const lastName = normalizeName(command.bookerLastName); assertTimeZone(command.bookerTimeZone); if ( !command.idempotencyKey.trim() || command.idempotencyKey.length > 200 || command.manageTokenExpiresAt.getTime() <= command.startsAt.getTime() ) { throw new AdminBookingError("invalid_request"); } if ( command.reschedule && (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,190}$/u.test( command.reschedule.previousBookingId ) || !Number.isSafeInteger(command.reschedule.manageTokenVersion) || command.reschedule.manageTokenVersion < 1 || !Number.isFinite( command.reschedule.manageTokenExpiresAfter.getTime() ) || !/^[a-f0-9]{64}$/u.test( command.reschedule.manageNonceHash )) ) { throw new AdminBookingError("invalid_request"); } const intakeAnswers = Object.fromEntries( Object.entries(command.intakeAnswers).map(([key, value]) => { const normalizedKey = key.trim(); const normalizedValue = value.trim(); if ( !normalizedKey || normalizedKey.length > 80 || normalizedValue.length > MAX_ANSWER_LENGTH ) { throw new AdminBookingError("invalid_answers"); } return [normalizedKey, normalizedValue]; }) ); return { ...command, bookerFirstName: firstName, bookerLastName: lastName, bookerEmail, bookerLocale: command.bookerLocale?.trim() || null, intakeAnswers, availableHostAdminUserIds: [ ...new Set(command.availableHostAdminUserIds), ], manualHostAdminUserId: command.manualHostAdminUserId?.trim() || null, dealId: command.dealId?.trim() || null, idempotencyKey: command.idempotencyKey.trim(), }; } function normalizeName(value: string): string { const normalized = value.trim().replace(/\s+/gu, " "); if (!normalized || normalized.length > MAX_NAME_LENGTH) { throw new AdminBookingError("invalid_name"); } return normalized; } function assertTimeZone(timeZone: string): void { try { new Intl.DateTimeFormat("de-DE", { timeZone }).format(new Date()); } catch { throw new AdminBookingError("invalid_time_zone"); } } function startOfUtcDay(value: Date): Date { return new Date( Date.UTC( value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate() ) ); } function endOfUtcDay(value: Date): Date { return new Date(startOfUtcDay(value).getTime() + DAY_MS); } export class AdminBookingError extends Error { readonly code: | "invalid_email" | "invalid_name" | "invalid_time_zone" | "invalid_request" | "invalid_answers" | "page_unavailable" | "invalid_slot" | "email_domain_denied" | "contact_ambiguous" | "deal_unavailable" | "booking_unavailable" | "slot_taken" | "rate_limited"; constructor(code: AdminBookingError["code"]) { super(code); this.name = "AdminBookingError"; this.code = code; } }