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 { createAdminEmailComposeService, createPrismaAdminEmailComposeRepository, } from "@hivegrid/db/admin-email-compose.server"; import { createPrismaAdminMailboxRepository, } from "@hivegrid/db/admin-mailboxes.server"; import { createAdminMailProviderGateway, type AdminMailConnectionProvider, type AdminOAuthCredentialBundle, } 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 AdminEmailOperatorContext = { readonly adminUserId: string; readonly email: string; readonly locale: string | null; readonly canReadAllCommunication: boolean; readonly connections: ReturnType; readonly mailboxes: ReturnType; readonly providers: ReturnType; readonly compose: ReturnType; 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 runAsAdminEmailOperator( request: Request, permission: | Extract< AdminPermissionName, | "admin_sales.email.connect" | "admin_sales.email.send" | "admin_sales.email.track" | "admin_sales.email.bulk_send" | "admin_sales.communication.read_all" > | readonly Extract< AdminPermissionName, | "admin_sales.email.connect" | "admin_sales.email.send" | "admin_sales.email.track" | "admin_sales.email.bulk_send" | "admin_sales.communication.read_all" >[], operation: (context: AdminEmailOperatorContext) => 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, locale: 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 canReadAllCommunication = await adminHasPermission( admin.id, "admin_sales.communication.read_all", db ); return operation({ adminUserId: admin.id, email: admin.email, locale: admin.locale, canReadAllCommunication, connections: createAdminConnectionsService({ repository: createPrismaAdminConnectionsRepository(db), authorize, }), mailboxes: createPrismaAdminMailboxRepository(db), providers: createAdminMailProviderGateway(), compose: createAdminEmailComposeService({ repository: createPrismaAdminEmailComposeRepository(db), authorize, }), actor: (reason) => ({ ...auditBase, reason }), }); }); } export async function completeAdminEmailConnection(input: { readonly context: AdminEmailOperatorContext; readonly provider: AdminMailConnectionProvider; readonly code: string; }) { const grant = await input.context.providers.exchange( input.provider, input.code ); const reason = "Persönliches Vertriebspostfach verbinden"; const actor = input.context.actor(reason); const connection = await input.context.connections.connect({ adminUserId: input.context.adminUserId, provider: input.provider, capability: "email", label: grant.account.displayName ?? grant.account.emailAddress, externalAccountId: grant.account.externalAccountId, externalAccountEmail: grant.account.emailAddress, scopes: grant.credentials.scopes, tokenExpiresAt: new Date(grant.credentials.expiresAt), credentials: grant.credentials, actor, }); const mailbox = await input.context.mailboxes.activate({ adminUserId: input.context.adminUserId, connectionId: connection.id, provider: input.provider, emailAddress: grant.account.emailAddress, displayName: grant.account.displayName, providerAccountId: grant.account.externalAccountId, actor, }); return { connectionId: connection.id, mailboxId: mailbox.id }; } export async function listAdminEmailConnectionSettings( context: AdminEmailOperatorContext ) { const accounts = await db.adminMailbox.findMany({ where: { adminUserId: context.adminUserId, archivedAt: null, }, orderBy: [{ normalizedEmail: "asc" }, { id: "asc" }], select: { id: true, connectionId: true, emailAddress: true, displayName: true, status: true, lastSyncAt: true, connection: { select: { provider: true, healthMessageKey: true, }, }, }, }); return accounts.map((account) => { if ( account.connection.provider !== "google_mail" && account.connection.provider !== "microsoft_mail" ) { throw new Error( "admin.sales.email.connections.errors.invalidProvider" ); } return { id: account.id, connectionId: account.connectionId, provider: account.connection.provider, emailAddress: account.emailAddress, displayName: account.displayName, status: account.status, lastSyncAt: account.lastSyncAt, healthMessageKey: account.connection.healthMessageKey, }; }); } export async function refreshAdminEmailConnection(input: { readonly context: AdminEmailOperatorContext; readonly connectionId: string; readonly provider: AdminMailConnectionProvider; }) { return input.context.connections.withCredentials( input.connectionId, input.context.adminUserId, async (raw) => { const current = credentialBundle(raw); const refreshed = await input.context.providers.refresh( input.provider, current ); return input.context.connections.refresh({ connectionId: input.connectionId, adminUserId: input.context.adminUserId, credentials: refreshed, scopes: refreshed.scopes, tokenExpiresAt: new Date(refreshed.expiresAt), actor: input.context.actor("OAuth-Token erneuern"), }); } ); } export async function disconnectAdminEmailConnection(input: { readonly context: AdminEmailOperatorContext; readonly connectionId: string; readonly mailboxId: string; readonly provider: AdminMailConnectionProvider; }) { await input.context.connections.disconnect({ connectionId: input.connectionId, adminUserId: input.context.adminUserId, actor: input.context.actor("Persönliches Vertriebspostfach trennen"), revokeProviderCredentials: (raw) => input.context.providers.revoke(input.provider, credentialBundle(raw)), }); return input.context.mailboxes.revoke({ adminUserId: input.context.adminUserId, mailboxId: input.mailboxId, actor: input.context.actor("Persönliches Vertriebspostfach trennen"), }); } function credentialBundle( raw: Readonly> ): AdminOAuthCredentialBundle { if ( typeof raw.accessToken !== "string" || typeof raw.refreshToken !== "string" || typeof raw.expiresAt !== "string" || !Array.isArray(raw.scopes) || raw.scopes.some((scope) => typeof scope !== "string") ) { throw new Error("admin.sales.email.connections.errors.invalidCredential"); } return { accessToken: raw.accessToken, refreshToken: raw.refreshToken, expiresAt: raw.expiresAt, scopes: raw.scopes as string[], }; }