Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,98 @@
import { adminBookingSettingsActionSchema, buildAdminBookingSettingsVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminBookingSettingsPage } from "~/components/screens/admin/sales/booking/AdminBookingSettingsPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { readAdminBookingSettings, runAsAdminBookingSettingsOperator } from "~/services/admin/admin-booking-settings.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminBookingSettingsOperator(request, async (context) => ({
vm: buildAdminBookingSettingsVM(await readAdminBookingSettings(context.adminUserId)),
}));
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
let payload: unknown;
try {
payload = JSON.parse(String(form.get("payload") ?? "{}"));
} catch {
return Response.json({ error: t("admin.sales.booking.settings.errors.invalid") }, { status: 400 });
}
const parsed = adminBookingSettingsActionSchema.safeParse(payload);
if (!parsed.success || parsed.data.intent !== "replace-availability") {
return Response.json({ error: t("admin.sales.booking.settings.errors.invalid") }, { status: 400 });
}
const command = parsed.data;
try {
await runAsAdminBookingSettingsOperator(request, async (context) => {
await context.settings.replaceOwnAvailability({
adminUserId: context.adminUserId,
timeZone: command.timeZone,
rules: command.rules,
overrides: command.overrides.map((override) => ({
...override,
date: new Date(`${override.date}T00:00:00.000Z`),
})),
actor: context.actor("Eigene Verfügbarkeit konfigurieren"),
});
});
const target = new URL(request.url);
target.searchParams.set("toast", "admin.sales.booking.settings.toast.availabilitySaved");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.booking.settings.errors.save") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminAvailabilitySettingsRoute() {
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const dispatch = (payload: Record<string, unknown>) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify(payload));
submit(form, { method: "post" });
};
return (
<AdminBookingSettingsPage
mode="availability"
vm={vm}
{...settingsHrefs()}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onSaveMeetingType: dispatch,
onSaveBookingPage: dispatch,
onReplaceAvailability: dispatch,
}}
/>
);
}
function settingsHrefs() {
return {
bookingsHref: adminPath("sales/bookings", { mode: "host-aware" }),
calendarsHref: adminPath("sales/settings/calendars", {
mode: "host-aware",
}),
meetingTypesHref: adminPath("sales/settings/meeting-types", {
mode: "host-aware",
}),
availabilityHref: adminPath("sales/settings/availability", {
mode: "host-aware",
}),
};
}
@@ -0,0 +1,80 @@
import { adminCalendarConnectionActionSchema, buildAdminCalendarConnectionsVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminCalendarConnectionsPage } from "~/components/screens/admin/sales/booking/AdminCalendarConnectionsPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import {
disconnectAdminCalendarConnection,
listAdminCalendarConnectionSettings,
runAsAdminCalendarOperator,
} from "~/services/admin/admin-calendar-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminCalendarOperator(request, async (context) => ({
vm: buildAdminCalendarConnectionsVM({
calendars: await listAdminCalendarConnectionSettings(context),
providerConfiguration: {
google_calendar: context.providers.configured("google_calendar"),
microsoft_calendar: context.providers.configured("microsoft_calendar"),
},
}),
}));
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
let payload: unknown;
try {
payload = JSON.parse(String(form.get("payload") ?? "{}"));
} catch {
return Response.json({ error: t("admin.sales.booking.calendars.errors.invalid") }, { status: 400 });
}
const parsed = adminCalendarConnectionActionSchema.safeParse(payload);
if (!parsed.success) {
return Response.json({ error: t("admin.sales.booking.calendars.errors.invalid") }, { status: 400 });
}
try {
await runAsAdminCalendarOperator(request, (context) => disconnectAdminCalendarConnection({ context, ...parsed.data }));
const target = new URL(adminPath("sales/settings/calendars", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", "admin.sales.booking.calendars.toast.disconnected");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.booking.calendars.errors.disconnect") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminCalendarConnectionsRoute() {
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
return (
<AdminCalendarConnectionsPage
vm={vm}
bookingsHref={adminPath("sales/bookings", { mode: "host-aware" })}
connectHref={(provider) =>
adminPath(`sales/settings/calendars/connect/${provider === "google_calendar" ? "google" : "microsoft"}`, { mode: "host-aware" })
}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onDisconnect: (input) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent: "disconnect", ...input }));
submit(form, { method: "post" });
},
}}
/>
);
}
@@ -0,0 +1,43 @@
import type { LoaderFunctionArgs } from "react-router";
import { consumeAdminCalendarOAuthState } from "~/services/admin/admin-calendar-oauth-state.server";
import {
completeAdminCalendarConnection,
runAsAdminCalendarOperator,
} from "~/services/admin/admin-calendar-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { parseProvider } from "../connect/$provider";
export async function loader({ request, params }: LoaderFunctionArgs) {
const provider = parseProvider(params.provider);
const url = new URL(request.url);
return runAsAdminCalendarOperator(request, async (context) => {
const challenge = consumeAdminCalendarOAuthState(request, {
expectedState: url.searchParams.get("state") ?? "",
expectedProvider: provider,
expectedAdminUserId: context.adminUserId,
});
const location = new URL(
adminPath("sales/settings/calendars", { mode: "host-aware" }),
request.url
);
if (!challenge.ok || !url.searchParams.get("code")) {
location.searchParams.set("status", "oauth-error");
} else {
await completeAdminCalendarConnection({
context,
provider,
code: url.searchParams.get("code") ?? "",
});
location.searchParams.set("status", "connected");
}
return new Response(null, {
status: 303,
headers: {
Location: location.toString(),
"Set-Cookie": challenge.clearCookie,
"Cache-Control": "no-store",
},
});
});
}
@@ -0,0 +1,31 @@
import type { LoaderFunctionArgs } from "react-router";
import { createAdminCalendarOAuthState } from "~/services/admin/admin-calendar-oauth-state.server";
import { runAsAdminCalendarOperator } from "~/services/admin/admin-calendar-connections.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const provider = parseProvider(params.provider);
return runAsAdminCalendarOperator(request, async (context) => {
const challenge = createAdminCalendarOAuthState({
adminUserId: context.adminUserId,
provider,
});
return new Response(null, {
status: 302,
headers: {
Location: context.providers.authorizationUrl(
provider,
challenge.state
),
"Set-Cookie": challenge.cookie,
"Cache-Control": "no-store",
},
});
});
}
export function parseProvider(value: string | undefined) {
if (value === "google") return "google_calendar" as const;
if (value === "microsoft") return "microsoft_calendar" as const;
throw new Response(null, { status: 404 });
}
@@ -0,0 +1,121 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
validateCsrf: vi.fn(),
list: vi.fn(),
disconnect: vi.fn(),
providers: {
configured: vi.fn(),
},
}));
vi.mock(
"~/components/screens/admin/sales/email/AdminEmailAccountsPage",
() => ({ AdminEmailAccountsPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
}));
vi.mock("~/services/admin/admin-email-connections.server", () => ({
runAsAdminEmailOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
adminUserId: "admin-1",
providers: mocks.providers,
})
),
listAdminEmailConnectionSettings: mocks.list,
disconnectAdminEmailConnection: mocks.disconnect,
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: mocks.validateCsrf,
}));
import { runAsAdminEmailOperator } from "~/services/admin/admin-email-connections.server";
import { action, loader } from "./email-accounts";
describe("admin email accounts route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.list.mockResolvedValue([]);
mocks.providers.configured.mockImplementation(
(provider: string) => provider === "google_mail"
);
});
it("builds a tenant-less provider capability view", async () => {
const result = await loader({
request: new Request(
"https://admin.hivegrid.de/sales/settings/email-accounts"
),
params: {},
context: {},
} as never);
expect(runAsAdminEmailOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.email.connect",
expect.any(Function)
);
expect(result.vm.providers).toEqual([
{
provider: "google_mail",
configured: true,
connected: false,
},
{
provider: "microsoft_mail",
configured: false,
connected: false,
},
]);
});
it("validates CSRF and disconnects the exact mailbox", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/settings/email-accounts",
{
method: "POST",
body: new URLSearchParams({
payload: JSON.stringify({
intent: "disconnect",
mailboxId: "mailbox-1",
connectionId: "connection-1",
provider: "google_mail",
}),
}),
}
),
params: {},
context: {},
} as never);
expect(mocks.validateCsrf).toHaveBeenCalledOnce();
expect(mocks.disconnect).toHaveBeenCalledWith({
context: expect.objectContaining({ adminUserId: "admin-1" }),
mailboxId: "mailbox-1",
connectionId: "connection-1",
provider: "google_mail",
});
expect(response.status).toBe(303);
});
it("rejects malformed actions before disconnect", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/settings/email-accounts",
{
method: "POST",
body: new URLSearchParams({ payload: "{" }),
}
),
params: {},
context: {},
} as never);
expect(response.status).toBe(400);
expect(mocks.disconnect).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,93 @@
import { adminEmailConnectionActionSchema, buildAdminEmailConnectionsVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminEmailAccountsPage } from "~/components/screens/admin/sales/email/AdminEmailAccountsPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { disconnectAdminEmailConnection, listAdminEmailConnectionSettings, runAsAdminEmailOperator } from "~/services/admin/admin-email-connections.server";
import { adminEmailWorkspaceHrefs } from "~/services/admin/admin-email-workspace.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminEmailOperator(request, "admin_sales.email.connect", async (context) => ({
vm: buildAdminEmailConnectionsVM({
accounts: await listAdminEmailConnectionSettings(context),
providerConfiguration: {
google_mail: context.providers.configured("google_mail"),
microsoft_mail: context.providers.configured("microsoft_mail"),
},
}),
hrefs: adminEmailWorkspaceHrefs(),
}));
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
let payload: unknown;
try {
payload = JSON.parse(String(form.get("payload") ?? "{}"));
} catch {
return Response.json({ error: t("admin.sales.email.accounts.errors.invalid") }, { status: 400 });
}
const parsed = adminEmailConnectionActionSchema.safeParse(payload);
if (!parsed.success) {
return Response.json({ error: t("admin.sales.email.accounts.errors.invalid") }, { status: 400 });
}
try {
const disconnect = {
mailboxId: parsed.data.mailboxId,
connectionId: parsed.data.connectionId,
provider: parsed.data.provider,
};
await runAsAdminEmailOperator(request, "admin_sales.email.connect", (context) =>
disconnectAdminEmailConnection({
context,
...disconnect,
})
);
const target = new URL(
adminPath("sales/settings/email-accounts", {
mode: "host-aware",
}),
request.url
);
target.searchParams.set("toast", "admin.sales.email.accounts.toast.disconnected");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.email.accounts.errors.disconnect") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminEmailAccountsRoute(): React.JSX.Element {
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
return (
<AdminEmailAccountsPage
vm={vm}
hrefs={hrefs}
salesHref={adminPath("sales/deals", { mode: "host-aware" })}
connectHref={(provider) => adminPath(`sales/settings/email-accounts/connect/${provider}`, { mode: "host-aware" })}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onDisconnect: (input) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent: "disconnect", ...input }));
submit(form, { method: "post" });
},
}}
/>
);
}
@@ -0,0 +1,58 @@
import type { LoaderFunctionArgs } from "react-router";
import {
consumeAdminEmailOAuthState,
} from "~/services/admin/admin-email-oauth-state.server";
import {
completeAdminEmailConnection,
runAsAdminEmailOperator,
} from "~/services/admin/admin-email-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { parseProvider } from "../connect/$provider";
export async function loader({ request, params }: LoaderFunctionArgs) {
const provider = parseProvider(params.provider);
const url = new URL(request.url);
const code = url.searchParams.get("code") ?? "";
const state = url.searchParams.get("state") ?? "";
return runAsAdminEmailOperator(
request,
"admin_sales.email.connect",
async (context) => {
const challenge = consumeAdminEmailOAuthState(request, {
expectedState: state,
expectedProvider: provider,
expectedAdminUserId: context.adminUserId,
});
if (!challenge.ok || !code) {
return redirectWithCookie(
new URL(
`${adminPath("sales/settings/email-accounts", { mode: "host-aware" })}?status=oauth-error`,
request.url
),
challenge.clearCookie
);
}
await completeAdminEmailConnection({ context, provider, code });
return redirectWithCookie(
new URL(
`${adminPath("sales/settings/email-accounts", { mode: "host-aware" })}?status=connected`,
request.url
),
challenge.clearCookie
);
}
);
}
function redirectWithCookie(location: URL, cookie: string): Response {
return new Response(null, {
status: 303,
headers: {
Location: location.toString(),
"Set-Cookie": cookie,
"Cache-Control": "no-store",
},
});
}
@@ -0,0 +1,38 @@
import type { LoaderFunctionArgs } from "react-router";
import {
createAdminEmailOAuthState,
} from "~/services/admin/admin-email-oauth-state.server";
import { runAsAdminEmailOperator } from "~/services/admin/admin-email-connections.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const provider = parseProvider(params.provider);
return runAsAdminEmailOperator(
request,
"admin_sales.email.connect",
async (context) => {
const challenge = createAdminEmailOAuthState({
adminUserId: context.adminUserId,
provider,
});
const location = context.providers.authorizationUrl(
provider,
challenge.state
);
return new Response(null, {
status: 302,
headers: {
Location: location,
"Set-Cookie": challenge.cookie,
"Cache-Control": "no-store",
},
});
}
);
}
export function parseProvider(value: string | undefined) {
if (value === "google") return "google_mail" as const;
if (value === "microsoft") return "microsoft_mail" as const;
throw new Response(null, { status: 404 });
}
@@ -0,0 +1,11 @@
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/fields-tags");
}
export function action({ request }: ActionFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/fields-tags");
}
@@ -0,0 +1,119 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
validateCsrf: vi.fn(),
requireAdmin: vi.fn(),
advancedService: {
listAutomationConfig: vi.fn(),
createAssignmentRule: vi.fn(),
createScoreRule: vi.fn(),
},
service: { listSources: vi.fn() },
access: {
canAdmin: true,
audit: vi.fn((reason: string) => ({
actorAdminUserId: "admin-1",
actorEmail: "admin@example.test",
actorIp: null,
actorUserAgent: null,
requestId: "request-1",
reason,
})),
},
}));
vi.mock("~/components/screens/admin/sales/leads/AdminSalesLeadSettingsPage", () => ({
AdminSalesLeadSettingsPage: () => null,
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
}));
vi.mock("~/services/admin/platform-leads.server", () => ({
listPlatformLeadAssignees: vi.fn(async () => [{ id: "admin-1", label: "Ada Admin" }]),
requirePlatformLeadAdmin: mocks.requireAdmin,
runAsPlatformLeadOperator: vi.fn(async (_request, operation) =>
operation({
access: mocks.access,
service: mocks.service,
advancedService: mocks.advancedService,
})
),
}));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: mocks.validateCsrf }));
import { action, loader } from "../../settings/leads";
describe("admin sales lead settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.advancedService.listAutomationConfig.mockResolvedValue({
assignmentRules: [],
scoreRules: [],
});
mocks.service.listSources.mockResolvedValue([{ id: "source-1", displayName: "Website" }]);
});
it("builds the tenant-less automation settings VM behind assignment permission", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/settings/leads"),
params: {},
context: {},
} as never);
expect(mocks.requireAdmin).toHaveBeenCalledWith(mocks.access);
expect(result.vm).toMatchObject({
canConfigure: true,
sourceOptions: [{ id: "source-1", label: "Website" }],
assigneeOptions: [{ id: "admin-1", label: "Ada Admin" }],
});
});
it("validates CSRF and creates a typed round-robin assignment rule", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/settings/leads", {
method: "POST",
body: new URLSearchParams({
payload: JSON.stringify({
intent: "create-assignment-rule",
name: "DACH Website",
priority: 10,
sourceId: "source-1",
region: "DACH",
strategy: "round_robin",
fixedAssigneeAdminUserId: null,
roundRobinAdminUserIds: ["admin-1"],
}),
}),
}),
params: {},
context: {},
} as never);
expect(mocks.validateCsrf).toHaveBeenCalledOnce();
expect(mocks.advancedService.createAssignmentRule).toHaveBeenCalledWith(
expect.objectContaining({
name: "DACH Website",
strategy: "round_robin",
roundRobinAdminUserIds: ["admin-1"],
actor: expect.objectContaining({ adminUserId: "admin-1" }),
})
);
expect(response.status).toBe(303);
expect(response.headers.get("Location")).toBe("https://admin.hivegrid.de/settings/leads?toast=admin.sales.leadSettings.toast.assignmentRuleCreated");
});
it("rejects malformed JSON without entering the operator service", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/settings/leads", {
method: "POST",
body: new URLSearchParams({ payload: "{" }),
}),
params: {},
context: {},
} as never);
expect(response.status).toBe(400);
expect(mocks.advancedService.createAssignmentRule).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,11 @@
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/leads");
}
export function action({ request }: ActionFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/leads");
}
@@ -0,0 +1,110 @@
import { adminBookingSettingsActionSchema, buildAdminBookingSettingsVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminBookingSettingsPage } from "~/components/screens/admin/sales/booking/AdminBookingSettingsPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { readAdminBookingSettings, runAsAdminBookingSettingsOperator } from "~/services/admin/admin-booking-settings.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminBookingSettingsOperator(request, async (context) => ({
vm: buildAdminBookingSettingsVM(await readAdminBookingSettings(context.adminUserId)),
}));
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
let payload: unknown;
try {
payload = JSON.parse(String(form.get("payload") ?? "{}"));
} catch {
return Response.json({ error: t("admin.sales.booking.settings.errors.invalid") }, { status: 400 });
}
const parsed = adminBookingSettingsActionSchema.safeParse(payload);
if (!parsed.success || parsed.data.intent === "replace-availability") {
return Response.json({ error: t("admin.sales.booking.settings.errors.invalid") }, { status: 400 });
}
const command = parsed.data;
try {
await runAsAdminBookingSettingsOperator(request, async (context) => {
if (command.intent === "save-meeting-type") {
const { intent: _intent, ...meetingType } = command;
await context.settings.saveMeetingType({
...meetingType,
intakeQuestions: [],
actor: context.actor("Meeting-Typ konfigurieren"),
});
} else {
const { intent: _intent, ...page } = command;
await context.settings.saveBookingPage({
...page,
actor: context.actor("Buchungsseite konfigurieren"),
});
}
});
const target = new URL(
adminPath("sales/settings/meeting-types", {
mode: "host-aware",
}),
request.url
);
target.searchParams.set(
"toast",
command.intent === "save-meeting-type" ? "admin.sales.booking.settings.toast.meetingTypeSaved" : "admin.sales.booking.settings.toast.bookingPageSaved"
);
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.booking.settings.errors.save") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminMeetingTypesSettingsRoute() {
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const dispatch = (payload: Record<string, unknown>) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify(payload));
submit(form, { method: "post" });
};
return (
<AdminBookingSettingsPage
mode="meeting-types"
vm={vm}
{...settingsHrefs()}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onSaveMeetingType: dispatch,
onSaveBookingPage: dispatch,
onReplaceAvailability: dispatch,
}}
/>
);
}
export function settingsHrefs() {
return {
bookingsHref: adminPath("sales/bookings", { mode: "host-aware" }),
calendarsHref: adminPath("sales/settings/calendars", {
mode: "host-aware",
}),
meetingTypesHref: adminPath("sales/settings/meeting-types", {
mode: "host-aware",
}),
availabilityHref: adminPath("sales/settings/availability", {
mode: "host-aware",
}),
};
}
@@ -0,0 +1,11 @@
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/pipelines");
}
export function action({ request }: ActionFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/pipelines");
}
@@ -0,0 +1,72 @@
import { adminEmailWorkspaceActionSchema, buildAdminEmailDomainsVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminEmailDomainsPage } from "~/components/screens/admin/sales/email/AdminEmailDomainsPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminEmailOperator } from "~/services/admin/admin-email-connections.server";
import { adminEmailWorkspaceHrefs, applyAdminEmailWorkspaceAction, readAdminEmailDomains } from "~/services/admin/admin-email-workspace.server";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
import { useSaveToast } from "~/hooks/use-save-toast";
type ActionData = { intent?: string; ok?: true; messageKey?: string; error?: string };
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminEmailOperator(request, "admin_sales.email.track", async (context) => ({
vm: buildAdminEmailDomainsVM(await readAdminEmailDomains(context)),
hrefs: adminEmailWorkspaceHrefs(),
}));
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const parsed = adminEmailWorkspaceActionSchema.safeParse(parsePayload(await request.formData()));
if (!parsed.success || parsed.data.intent !== "save-domain") {
return Response.json({ error: t("admin.sales.email.errors.invalidAction") }, { status: 400 });
}
try {
await runAsAdminEmailOperator(request, "admin_sales.email.track", (context) => applyAdminEmailWorkspaceAction(context, parsed.data));
return { intent: parsed.data.intent, ok: true, messageKey: "admin.sales.email.toast.domainSaved" } satisfies ActionData;
} catch {
return Response.json({ error: t("admin.sales.email.errors.saveFailed") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminEmailDomainsRoute() {
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const submit = useSubmit();
useSaveToast(actionData?.ok ? actionData : undefined);
return (
<AdminEmailDomainsPage
vm={vm}
hrefs={hrefs}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onSaveDomain: (input) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent: "save-domain", ...input }));
submit(form, { method: "post" });
},
}}
/>
);
}
function parsePayload(form: FormData) {
try {
return JSON.parse(String(form.get("payload") ?? "{}")) as unknown;
} catch {
return null;
}
}
@@ -0,0 +1,11 @@
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/telephony");
}
export function action({ request }: ActionFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/telephony");
}
@@ -0,0 +1,7 @@
import type { LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/telephony/callback/aircall");
}
@@ -0,0 +1,7 @@
import type { LoaderFunctionArgs } from "react-router";
import { redirectLegacyAdminSettingsRoute } from "~/utils/navigation/legacyAdminSettingsRedirect.server";
export function loader({ request }: LoaderFunctionArgs) {
return redirectLegacyAdminSettingsRoute(request, "settings/telephony/connect/aircall");
}