158 lines
5.3 KiB
TypeScript
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,
|
|
});
|
|
}
|