Files

158 lines
5.3 KiB
TypeScript

import type { AdminPermissionName } from "@hivegrid/db/admin-permissions";
import { adminHasPermission } from "@hivegrid/db/admin-rbac.server";
import {
createAdminCalendarService,
createPrismaAdminCalendarRepository,
} from "@hivegrid/db/admin-calendar.server";
import {
createAdminConnectionsService,
createPrismaAdminConnectionsRepository,
} from "@hivegrid/db/admin-connections.server";
import type { AdminCalendarProviderName } from "@hivegrid/integrations/admin-calendar-provider";
import { createAdminCalendarOAuthGateway } from "@hivegrid/integrations/admin-calendar-oauth.server";
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 AdminCalendarOperatorContext = {
readonly adminUserId: string;
readonly connections: ReturnType<typeof createAdminConnectionsService>;
readonly calendars: ReturnType<typeof createAdminCalendarService>;
readonly providers: ReturnType<typeof createAdminCalendarOAuthGateway>;
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 runAsAdminCalendarOperator<T>(
request: Request,
operation: (context: AdminCalendarOperatorContext) => Promise<T>
) {
return runAsAdminIdentity(
request,
"admin_sales.booking.manage",
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 (permission: AdminPermissionName) => {
if (!(await adminHasPermission(admin.id, permission, db))) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
};
const actorBase = {
adminUserId: admin.id,
email: admin.email,
requestId: extractWebRequestId(request),
ip: extractWebActorIp(request),
userAgent: extractWebActorUserAgent(request),
};
return operation({
adminUserId: admin.id,
connections: createAdminConnectionsService({
repository: createPrismaAdminConnectionsRepository(db),
authorize,
permission: "admin_sales.booking.manage",
}),
calendars: createAdminCalendarService({
repository: createPrismaAdminCalendarRepository(db),
authorize,
}),
providers: createAdminCalendarOAuthGateway(),
actor: (reason) => ({ ...actorBase, reason }),
});
}
);
}
export async function completeAdminCalendarConnection(input: {
readonly context: AdminCalendarOperatorContext;
readonly provider: AdminCalendarProviderName;
readonly code: string;
}) {
const grant = await input.context.providers.exchange(
input.provider,
input.code
);
const actor = input.context.actor("Persönlichen Kalender verbinden");
const connection = await input.context.connections.connect({
adminUserId: input.context.adminUserId,
provider: input.provider,
capability: "calendar",
label: grant.account.displayName,
externalAccountId: grant.account.externalAccountId,
externalAccountEmail: grant.account.emailAddress,
scopes: grant.credentials.scopes,
tokenExpiresAt: new Date(grant.credentials.expiresAt),
credentials: grant.credentials,
actor,
});
const calendar = await input.context.calendars.activate({
adminUserId: input.context.adminUserId,
dataConnectionId: connection.id,
externalCalendarId: grant.calendar.externalCalendarId,
externalCalendarLabel: grant.calendar.label,
timeZone: grant.calendar.timeZone,
actor,
});
return { connectionId: connection.id, calendarConnectionId: calendar.id };
}
export async function listAdminCalendarConnectionSettings(
context: AdminCalendarOperatorContext
) {
return db.adminCalendarConnection.findMany({
where: { adminUserId: context.adminUserId, archivedAt: null },
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
select: {
id: true,
dataConnectionId: true,
externalCalendarLabel: true,
timeZone: true,
status: true,
lastSyncAt: true,
healthMessageKey: true,
dataConnection: {
select: {
provider: true,
externalAccountEmail: true,
},
},
},
});
}
export async function disconnectAdminCalendarConnection(input: {
readonly context: AdminCalendarOperatorContext;
readonly calendarConnectionId: string;
readonly dataConnectionId: string;
}) {
const actor = input.context.actor("Persönlichen Kalender trennen");
await input.context.calendars.disconnect({
adminUserId: input.context.adminUserId,
calendarConnectionId: input.calendarConnectionId,
actor,
});
return input.context.connections.disconnect({
adminUserId: input.context.adminUserId,
connectionId: input.dataConnectionId,
actor,
revokeProviderCredentials: async () => undefined,
});
}