import { createHash } from "node:crypto"; import type { AdminPermissionName } from "@hivegrid/db/admin-permissions"; import { adminHasPermission } from "@hivegrid/db/admin-rbac.server"; import { createAdminConnectionsService, createPrismaAdminConnectionsRepository, } from "@hivegrid/db/admin-connections.server"; import { createAdminTelephonyService, createPrismaAdminTelephonyRepository, } from "@hivegrid/db/admin-telephony.server"; import { createAdminTelephonyActionsService, createPrismaAdminTelephonyActionsRepository, } from "@hivegrid/db/admin-telephony-actions.server"; import { createAdminTelephonyRecordingService, createPrismaAdminTelephonyRecordingRepository, } from "@hivegrid/db/admin-telephony-recordings.server"; import { AIRCALL_CALL_WEBHOOK_EVENTS, AIRCALL_OAUTH_SCOPE, aircallTelephonyProvider, exchangeAircallCodeForToken, resolveAircallOAuthConfig, } from "@hivegrid/integrations"; import { runAsAdminIdentity } from "~/services/admin/admin-identity.server"; import { extractWebActorIp, extractWebActorUserAgent, extractWebRequestId, } from "~/utils/audit/withAuditContext"; import { db } from "~/utils/db.server"; import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server"; export type AdminTelephonyOperatorContext = { readonly adminUserId: string; readonly email: string; readonly connections: ReturnType; readonly telephony: ReturnType; readonly actions: ReturnType; readonly recordings: ReturnType< typeof createAdminTelephonyRecordingService >; readonly canCall: boolean; readonly canReadAllCommunication: boolean; readonly canManageSettings: boolean; readonly canManageRecording: boolean; readonly actor: (reason: string) => { readonly adminUserId: string; readonly email: string; readonly reason: string; readonly requestId: string | null; readonly ip: string | null; readonly userAgent: string | null; }; }; export async function runAsAdminTelephonyOperator( request: Request, permission: | Extract< AdminPermissionName, | "admin_sales.phone.call" | "admin_sales.phone.recording" | "admin_sales.integrations.manage" | "admin_sales.communication.read_all" > | readonly Extract< AdminPermissionName, | "admin_sales.phone.call" | "admin_sales.phone.recording" | "admin_sales.integrations.manage" | "admin_sales.communication.read_all" >[], operation: (context: AdminTelephonyOperatorContext) => Promise ): Promise { return runAsAdminIdentity(request, permission, async (session) => { const admin = await db.adminUser.findFirst({ where: { id: session.adminUserId, status: "active" }, select: { id: true, email: true }, }); if (!admin) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 }); const authorize = async (requested: AdminPermissionName) => { if (!(await adminHasPermission(admin.id, requested, db))) { throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 }); } }; const auditBase = { adminUserId: admin.id, email: admin.email, requestId: extractWebRequestId(request), ip: extractWebActorIp(request), userAgent: extractWebActorUserAgent(request), }; const [ canCall, canManageSettings, canManageRecording, canReadAllCommunication, ] = await Promise.all([ adminHasPermission(admin.id, "admin_sales.phone.call", db), adminHasPermission(admin.id, "admin_sales.integrations.manage", db), adminHasPermission(admin.id, "admin_sales.phone.recording", db), adminHasPermission( admin.id, "admin_sales.communication.read_all", db ), ]); return operation({ adminUserId: admin.id, email: admin.email, connections: createAdminConnectionsService({ repository: createPrismaAdminConnectionsRepository(db), authorize, permission: "admin_sales.integrations.manage", }), telephony: createAdminTelephonyService({ repository: createPrismaAdminTelephonyRepository(db), authorize, }), actions: createAdminTelephonyActionsService({ repository: createPrismaAdminTelephonyActionsRepository(db), authorize, }), recordings: createAdminTelephonyRecordingService({ repository: createPrismaAdminTelephonyRecordingRepository(db), authorize, }), canCall, canReadAllCommunication, canManageSettings, canManageRecording, actor: (reason) => ({ ...auditBase, reason }), }); }); } export function getAdminAircallAuthorizationUrl(state: string): string { const config = resolveAircallOAuthConfig(); if (!config) { throw new Error("admin.sales.telephony.errors.aircallNotConfigured"); } const params = new URLSearchParams({ client_id: config.clientId, redirect_uri: config.redirectUri, response_type: "code", scope: AIRCALL_OAUTH_SCOPE, state, }); return `https://dashboard.aircall.io/oauth/authorize?${params.toString()}`; } export async function completeAdminAircallConnection(input: { readonly context: AdminTelephonyOperatorContext; readonly code: string; readonly webhookUrl?: string; }) { const config = resolveAircallOAuthConfig(); const webhookUrl = input.webhookUrl ?? process.env.ADMIN_AIRCALL_WEBHOOK_URL?.trim(); if (!config || !webhookUrl) { throw new Error("admin.sales.telephony.errors.aircallNotConfigured"); } const credentials = await exchangeAircallCodeForToken(config, input.code); await aircallTelephonyProvider.probe(credentials); const users = await aircallTelephonyProvider.listUsers(credentials); const matchingUsers = users.filter( (user) => user.email === input.context.email.trim().toLowerCase() ); if (matchingUsers.length !== 1) { throw new Error( matchingUsers.length === 0 ? "admin.sales.telephony.errors.aircallUserMissing" : "admin.sales.telephony.errors.aircallUserAmbiguous" ); } const providerUser = matchingUsers[0]!; const phoneNumbers = await aircallTelephonyProvider.listUserNumbers( credentials, providerUser.id ); if (phoneNumbers.length === 0) { throw new Error("admin.sales.telephony.errors.aircallNumberMissing"); } const webhook = await aircallTelephonyProvider.createWebhook(credentials, { name: `admin-sales-${input.context.adminUserId}`, url: webhookUrl, events: AIRCALL_CALL_WEBHOOK_EVENTS, }); let connectionId: string | null = null; try { const actor = input.context.actor("Aircall für Admin Sales verbinden"); const connection = await input.context.connections.connect({ adminUserId: input.context.adminUserId, provider: "aircall", capability: "telephony", label: providerUser.name, externalAccountId: providerUser.id, externalAccountEmail: providerUser.email, scopes: [AIRCALL_OAUTH_SCOPE], tokenExpiresAt: null, credentials: { accessToken: credentials.accessToken }, actor, }); connectionId = connection.id; await input.context.telephony.activateConnection({ adminUserId: input.context.adminUserId, connectionId: connection.id, providerUserId: providerUser.id, providerUserEmail: providerUser.email, defaultProviderNumberId: phoneNumbers.length === 1 ? phoneNumbers[0]!.id : providerUser.defaultNumberId, webhookRegistrationId: webhook.id, webhookTokenHash: createHash("sha256") .update(webhook.token, "utf8") .digest("hex"), phoneNumbers: phoneNumbers.map((number) => ({ providerNumberId: number.id, label: number.label, e164: number.e164, countryCode: number.countryCode, selected: true, })), actor, }); return { connectionId: connection.id }; } catch (error) { await aircallTelephonyProvider .deleteWebhook(credentials, webhook.id) .catch(() => undefined); if (connectionId) { await input.context.connections .disconnect({ connectionId, adminUserId: input.context.adminUserId, actor: input.context.actor( "Unvollständige Aircall-Verbindung zurückrollen" ), revokeProviderCredentials: () => Promise.resolve(), }) .catch(() => undefined); } throw error; } } export async function listAdminTelephonyConnectionSettings( context: AdminTelephonyOperatorContext ) { return db.adminPhoneConnection.findMany({ where: { adminUserId: context.adminUserId, archivedAt: null }, orderBy: [{ createdAt: "asc" }, { id: "asc" }], select: { id: true, connectionId: true, providerUserId: true, providerUserEmail: true, defaultPhoneNumberId: true, webhookVerifiedAt: true, lastEventAt: true, connection: { select: { label: true, status: true, healthMessageKey: true, webhookRegistrationId: true, }, }, phoneNumbers: { where: { archivedAt: null }, orderBy: [{ label: "asc" }, { id: "asc" }], select: { id: true, label: true, e164: true, selected: true, }, }, }, }); }