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,65 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { readAdminBookingWorkspace, runAsAdminBookingOperator } =
vi.hoisted(() => ({
readAdminBookingWorkspace: vi.fn(),
runAsAdminBookingOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
adminUserId: "admin-1",
email: "admin@email.com",
})
),
}));
vi.mock(
"~/components/screens/admin/sales/booking/AdminBookingWorkspacePage",
() => ({ AdminBookingWorkspacePage: () => null })
);
vi.mock("~/services/admin/admin-booking-workspace.server", () => ({
runAsAdminBookingOperator,
readAdminBookingWorkspace,
adminBookingOrigin: () => "https://meet.hivegrid.de",
}));
import { loader } from "./bookings";
describe("admin booking workspace route", () => {
beforeEach(() => {
vi.clearAllMocks();
readAdminBookingWorkspace.mockResolvedValue({
meetingTypes: [],
pages: [],
bookings: [],
connectedCalendars: 0,
});
});
it("builds its VM behind the dedicated booking permission", async () => {
const result = await loader({
request: new Request(
"https://admin.hivegrid.de/sales/bookings"
),
params: {},
context: {},
} as never);
expect(runAsAdminBookingOperator).toHaveBeenCalledWith(
expect.any(Request),
[
"admin_sales.booking.manage",
"admin_sales.communication.read_all",
],
expect.any(Function)
);
expect(result.vm).toMatchObject({
stats: {
upcoming: 0,
publishedPages: 0,
activeMeetingTypes: 0,
connectedCalendars: 0,
},
});
});
});
@@ -0,0 +1,53 @@
import { buildAdminBookingWorkspaceVM } from "@hivegrid/view-models";
import type { LoaderFunctionArgs } from "react-router";
import { useLoaderData } from "react-router";
import { AdminBookingWorkspacePage } from "~/components/screens/admin/sales/booking/AdminBookingWorkspacePage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import {
adminBookingOrigin,
readAdminBookingWorkspace,
runAsAdminBookingOperator,
} from "~/services/admin/admin-booking-workspace.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminBookingOperator(
request,
[
"admin_sales.booking.manage",
"admin_sales.communication.read_all",
],
async (context) => ({
vm: buildAdminBookingWorkspaceVM({
...(await readAdminBookingWorkspace(context)),
bookingOrigin: adminBookingOrigin(request),
}),
})
);
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminBookingWorkspaceRoute(): React.JSX.Element {
const { vm } = useLoaderData<typeof loader>();
return (
<AdminBookingWorkspacePage
vm={vm}
salesHref={adminPath("sales/deals", { mode: "host-aware" })}
settingsHrefs={{
calendars: adminPath("sales/settings/calendars", {
mode: "host-aware",
}),
meetingTypes: adminPath("sales/settings/meeting-types", {
mode: "host-aware",
}),
availability: adminPath("sales/settings/availability", {
mode: "host-aware",
}),
}}
/>
);
}
@@ -0,0 +1,134 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { context, applyAction, readWorkspace } = vi.hoisted(() => ({
context: {
adminUserId: "admin-1",
canManageSettings: true,
canManageRecording: true,
},
applyAction: vi.fn(),
readWorkspace: vi.fn(),
}));
vi.mock(
"~/components/screens/admin/sales/telephony/AdminTelephonyWorkspacePage",
() => ({ AdminTelephonyWorkspacePage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-telephony-connections.server", () => ({
runAsAdminTelephonyOperator: vi.fn(
async (_request, _permission, operation) => operation(context)
),
}));
vi.mock("~/services/admin/admin-telephony-workspace.server", () => ({
adminTelephonyWorkspaceHrefs: vi.fn(() => ({
calls: "/sales/calls",
settings: "/settings/telephony",
newLead: "/leads/new",
})),
applyAdminTelephonyWorkspaceAction: applyAction,
readAdminTelephonyWorkspace: readWorkspace,
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./calls";
describe("admin telephony workspace route", () => {
beforeEach(() => {
vi.clearAllMocks();
readWorkspace.mockResolvedValue({
calls: [],
selectedCallId: null,
dispositions: [],
contacts: [],
policy: null,
dialerLists: [],
permissions: {
canCall: true,
canManageSettings: true,
canManageRecording: true,
},
});
});
it("builds the view model behind the telephony call permission", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/sales/calls"),
params: {},
context: {},
} as never);
expect(runAsAdminTelephonyOperator).toHaveBeenCalledWith(
expect.any(Request),
[
"admin_sales.phone.call",
"admin_sales.communication.read_all",
],
expect.any(Function)
);
expect(result.vm.status).toBe("empty");
});
it("validates and delegates a call outcome action", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/calls", {
method: "POST",
body: new URLSearchParams({
payload: JSON.stringify({
intent: "save-outcome",
callSessionId: "call-1",
dispositionCode: "reached",
note: "Demo vereinbart",
callbackTitle: null,
callbackDueAt: null,
reason: "Anrufergebnis speichern",
}),
}),
}),
params: {},
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(applyAction).toHaveBeenCalledWith(
context,
expect.objectContaining({
intent: "save-outcome",
dispositionCode: "reached",
})
);
expect(response).toEqual({
intent: "save-outcome",
ok: true,
messageKey: "admin.sales.telephony.toast.outcomeSaved",
});
});
it("does not expose a silent unknown-caller lead creation action", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/calls", {
method: "POST",
body: new URLSearchParams({
payload: JSON.stringify({
intent: "create-lead",
phone: "+4930123456",
}),
}),
}),
params: {},
context: {},
} as never);
expect(response.status).toBe(400);
expect(applyAction).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,152 @@
import { randomUUID } from "node:crypto";
import {
adminTelephonyActionSchema,
buildAdminTelephonyWorkspaceVM,
} from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useTranslation } from "react-i18next";
import {
useActionData,
useLoaderData,
useNavigate,
useNavigation,
useSubmit,
} from "react-router";
import { AdminTelephonyWorkspacePage } from "~/components/screens/admin/sales/telephony/AdminTelephonyWorkspacePage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import {
adminTelephonyWorkspaceHrefs,
applyAdminTelephonyWorkspaceAction,
readAdminTelephonyWorkspace,
} from "~/services/admin/admin-telephony-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 };
const TELEPHONY_SUCCESS_KEYS: Readonly<Record<string, string>> = {
"save-outcome": "admin.sales.telephony.toast.outcomeSaved",
"confirm-match": "admin.sales.telephony.toast.matchConfirmed",
"queue-call": "admin.sales.telephony.toast.callQueued",
"create-dialer": "admin.sales.telephony.toast.dialerCreated",
"next-dialer": "admin.sales.telephony.toast.nextDialerActivated",
"finish-dialer": "admin.sales.telephony.toast.dialerEntryFinished",
"update-policy": "admin.sales.telephony.toast.policySaved",
"update-recording-policy": "admin.sales.telephony.toast.recordingPolicySaved",
"confirm-recording-consent": "admin.sales.telephony.toast.recordingConsentConfirmed",
};
export async function loader({ request }: LoaderFunctionArgs) {
const selectedCallId = new URL(request.url).searchParams.get("call");
return runAsAdminTelephonyOperator(
request,
[
"admin_sales.phone.call",
"admin_sales.communication.read_all",
],
async (context) => ({
vm: buildAdminTelephonyWorkspaceVM(
await readAdminTelephonyWorkspace(context, selectedCallId)
),
hrefs: adminTelephonyWorkspaceHrefs(),
})
);
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const raw = parsePayload(form);
if (
raw &&
typeof raw === "object" &&
"intent" in raw &&
raw.intent === "queue-call" &&
!("idempotencyKey" in raw)
) {
Object.assign(raw, { idempotencyKey: randomUUID() });
}
const parsed = adminTelephonyActionSchema.safeParse(raw);
if (!parsed.success) {
return Response.json(
{ error: t("admin.sales.telephony.errors.invalidAction") },
{ status: 400 }
);
}
try {
await runAsAdminTelephonyOperator(
request,
parsed.data.intent === "update-policy"
? "admin_sales.integrations.manage"
: parsed.data.intent === "update-recording-policy" ||
parsed.data.intent === "confirm-recording-consent"
? "admin_sales.phone.recording"
: "admin_sales.phone.call",
(context) =>
applyAdminTelephonyWorkspaceAction(context, parsed.data)
);
return { intent: parsed.data.intent, ok: true, messageKey: TELEPHONY_SUCCESS_KEYS[parsed.data.intent] } satisfies ActionData;
} catch {
return Response.json(
{ error: t("admin.sales.telephony.errors.actionFailed") },
{ status: 400 }
);
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminTelephonyWorkspaceRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const navigate = useNavigate();
const submit = useSubmit();
useSaveToast(actionData?.ok ? actionData : undefined);
return (
<AdminTelephonyWorkspacePage
vm={vm}
hrefs={hrefs}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onOpenCall: (callId) =>
navigate(`?call=${encodeURIComponent(callId)}`),
onSubmit: (payload) => {
const form = appendCSRFToken(new FormData());
form.set(
"payload",
JSON.stringify({
...payload,
reason: t(
`admin.sales.telephony.audit.${payload.intent.replaceAll("-", "_")}`
),
})
);
submit(form, { method: "post" });
},
}}
/>
);
}
function parsePayload(form: FormData): Record<string, unknown> | null {
try {
const parsed = JSON.parse(String(form.get("payload") ?? "{}")) as unknown;
return parsed && typeof parsed === "object"
? (parsed as Record<string, unknown>)
: null;
} catch {
return null;
}
}
@@ -0,0 +1,31 @@
// @vitest-environment node
import { describe, expect, it, vi } from "vitest";
vi.mock("~/services/admin/admin-identity.server", () => ({
requireAdminIdentityPermission: vi.fn(),
}));
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
import { loader } from "./dialer";
describe("admin telephony dialer route", () => {
it("keeps the dedicated dialer URL permission-gated and reachable", async () => {
const request = new Request(
"https://admin.hivegrid.de/sales/calls/dialer"
);
const response = await loader({
request,
params: {},
context: {},
} as never);
expect(requireAdminIdentityPermission).toHaveBeenCalledWith(
request,
"admin_sales.phone.call"
);
expect(response.status).toBe(302);
expect(response.headers.get("location")).toBe(
"https://admin.hivegrid.de/sales/calls#dialer"
);
});
});
@@ -0,0 +1,19 @@
import type { LoaderFunctionArgs } from "react-router";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
export async function loader({ request }: LoaderFunctionArgs) {
await requireAdminIdentityPermission(request, "admin_sales.phone.call");
return Response.redirect(
new URL(
`${adminPath("sales/calls", { mode: "host-aware" })}#dialer`,
request.url
),
302
);
}
export default function AdminTelephonyDialerRoute(): null {
return null;
}
@@ -0,0 +1,101 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
getPlayback: vi.fn(),
readPlayback: vi.fn(),
writeAudit: vi.fn(),
}));
vi.mock("@hivegrid/db/admin-telephony-recordings.server", () => ({
getAdminCallRecordingPlayback: mocks.getPlayback,
}));
vi.mock("@hivegrid/db/admin-sales-core.server", () => ({
writeAdminSalesAudit: mocks.writeAudit,
}));
vi.mock("~/services/admin/admin-telephony-recording-playback.server", () => ({
readAdminCallRecordingPlayback: mocks.readPlayback,
}));
vi.mock("~/services/admin/admin-telephony-connections.server", () => ({
runAsAdminTelephonyOperator: async (
_request: Request,
permission: readonly string[],
operation: (context: unknown) => Promise<unknown>
) => {
expect(permission).toEqual([
"admin_sales.phone.recording",
"admin_sales.communication.read_all",
]);
return operation({
adminUserId: "admin_1",
canReadAllCommunication: false,
actor: (reason: string) => ({
adminUserId: "admin_1",
email: "admin@example.test",
reason,
}),
});
},
}));
vi.mock("~/utils/db.server", () => ({ db: { marker: "db" } }));
import { loader } from "./$recordingId";
describe("admin call recording route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.getPlayback.mockResolvedValue({
id: "recording_1",
adminUserId: "admin_1",
callSessionId: "call_1",
});
mocks.readPlayback.mockResolvedValue(
Uint8Array.from(Buffer.from("audio"))
);
mocks.writeAudit.mockResolvedValue(undefined);
});
it("returns a no-store audio response and audits successful playback", async () => {
const response = await loader({
request: new Request(
"http://admin.localhost:3000/sales/calls/recordings/recording_1"
),
params: { recordingId: "recording_1" },
context: {},
} as never);
expect(response).toBeInstanceOf(Response);
expect((response as Response).headers.get("cache-control")).toBe(
"private, no-store"
);
expect((response as Response).headers.get("content-type")).toBe(
"audio/mpeg"
);
expect(await (response as Response).text()).toBe("audio");
expect(mocks.writeAudit).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
action: "admin.sales.telephony.recording.played",
targetId: "recording_1",
after: expect.objectContaining({
dataOwnerAdminUserId: "admin_1",
foreignAccess: false,
}),
})
);
});
it("returns 404 when no clean owner-bound recording exists", async () => {
mocks.getPlayback.mockResolvedValue(null);
await expect(
loader({
request: new Request(
"http://admin.localhost:3000/sales/calls/recordings/missing"
),
params: { recordingId: "missing" },
context: {},
} as never)
).rejects.toMatchObject({ status: 404 });
expect(mocks.readPlayback).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,65 @@
import {
getAdminCallRecordingPlayback,
} from "@hivegrid/db/admin-telephony-recordings.server";
import { writeAdminSalesAudit } from "@hivegrid/db/admin-sales-core.server";
import type { LoaderFunctionArgs } from "react-router";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { readAdminCallRecordingPlayback } from "~/services/admin/admin-telephony-recording-playback.server";
import { db } from "~/utils/db.server";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
export async function loader({ params, request }: LoaderFunctionArgs) {
const recordingId = params.recordingId;
if (!recordingId) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
try {
return await runAsAdminTelephonyOperator(
request,
[
"admin_sales.phone.recording",
"admin_sales.communication.read_all",
],
async (context) => {
const recording = await getAdminCallRecordingPlayback(db, {
adminUserId: context.adminUserId,
recordingId,
canReadAllCommunication: context.canReadAllCommunication,
});
if (!recording) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
const bytes = await readAdminCallRecordingPlayback({
recording,
signal: request.signal,
});
await writeAdminSalesAudit(db, {
actor: context.actor("Anrufaufzeichnung abgespielt"),
action: "admin.sales.telephony.recording.played",
targetType: "AdminCallRecording",
targetId: recording.id,
after: {
callSessionId: recording.callSessionId,
dataOwnerAdminUserId: recording.adminUserId,
foreignAccess:
recording.adminUserId !== context.adminUserId,
},
});
return new Response(Uint8Array.from(bytes).buffer, {
status: 200,
headers: {
"Cache-Control": "private, no-store",
"Content-Disposition": `inline; filename="call-${recording.callSessionId}.mp3"`,
"Content-Length": String(bytes.byteLength),
"Content-Type": "audio/mpeg",
"X-Content-Type-Options": "nosniff",
},
});
}
);
} catch (error) {
if (error instanceof Response) throw error;
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
}
@@ -0,0 +1,26 @@
import type { LoaderFunctionArgs, MetaFunction } from "react-router";
import { Outlet } from "react-router";
import ServerError from "~/components/ui/errors/ServerError";
import { getTranslations } from "~/locale/i18next.server";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
export async function loader({ request }: LoaderFunctionArgs) {
const { t } = await getTranslations(request);
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
return {
title: `${t("admin.sales.companies.title")} | ${process.env.APP_NAME}`,
};
}
export const meta: MetaFunction<typeof loader> = ({ data }) => [
{ title: data?.title },
];
export default function AdminSalesCompaniesLayout(): React.JSX.Element {
return <Outlet />;
}
export function ErrorBoundary(): React.JSX.Element {
return <ServerError />;
}
@@ -0,0 +1,56 @@
import { buildAdminSalesCompanyDetailVM } from "@hivegrid/view-models";
import type { LoaderFunctionArgs } from "react-router";
import { useLoaderData } from "react-router";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { AdminSalesCompanyDetailPage } from "~/components/screens/admin/sales/data/AdminSalesCompaniesPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const companyId = params.id;
if (!companyId) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
const { locale } = await getTranslations(request);
return runAsAdminSalesDataOperator(
request,
"admin_sales.crm.read",
async ({ service }) => {
const source = await service.getCompanyDetail(companyId);
if (!source) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
return {
vm: buildAdminSalesCompanyDetailVM({
source,
locale,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildDealHref: (dealId) =>
adminPath(`sales/deals/${encodeURIComponent(dealId)}`, {
mode: "host-aware",
}),
}),
};
}
);
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesCompanyDetailRoute(): React.JSX.Element {
const { vm } = useLoaderData<typeof loader>();
return (
<AdminSalesCompanyDetailPage
vm={vm}
companiesHref={adminPath("sales/companies", { mode: "host-aware" })}
/>
);
}
@@ -0,0 +1,112 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, runAsAdminSalesDataOperator } = vi.hoisted(() => {
const service = {
listWorkspace: vi.fn(),
getCompanyDetail: vi.fn(),
};
return {
service,
runAsAdminSalesDataOperator: vi.fn(
async (
_request: Request,
_permission: string,
callback: (context: {
service: typeof service;
canWrite: boolean;
canExport: boolean;
}) => unknown
) =>
callback({
service,
canWrite: true,
canExport: true,
})
),
};
});
vi.mock("~/services/admin/admin-sales-data.server", () => ({
runAsAdminSalesDataOperator,
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ locale: "de-DE" })),
}));
vi.mock("~/components/screens/admin/sales/data/AdminSalesCompaniesPage", () => ({
AdminSalesCompaniesPage: () => null,
AdminSalesCompanyDetailPage: () => null,
}));
import { loader as detailLoader } from "./$id";
import { loader as listLoader } from "./index";
const emptyWorkspace = {
companies: [],
contacts: [],
tags: [],
customFields: [],
importJobs: [],
exportJobs: [],
};
describe("admin sales company routes", () => {
beforeEach(() => {
vi.clearAllMocks();
service.listWorkspace.mockResolvedValue(emptyWorkspace);
service.getCompanyDetail.mockResolvedValue(null);
});
it("loads the company list through the CRM read boundary", async () => {
const result = await listLoader({
request: new Request("https://admin.hivegrid.de/sales/companies"),
params: {},
context: {},
} as never);
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(result.vm).toMatchObject({ companies: [], status: "empty" });
});
it("builds detail links and returns 404 for an unknown company", async () => {
service.getCompanyDetail.mockResolvedValueOnce({
id: "company_1",
name: "Analytical Engines",
legalName: null,
domain: null,
website: null,
phone: null,
region: null,
countryCode: null,
industry: null,
employeeRange: null,
contacts: [],
deals: [],
activities: [],
});
const result = await detailLoader({
request: new Request(
"https://admin.hivegrid.de/sales/companies/company_1"
),
params: { id: "company_1" },
context: {},
} as never);
expect(result.vm).toMatchObject({
id: "company_1",
name: "Analytical Engines",
});
await expect(
detailLoader({
request: new Request(
"https://admin.hivegrid.de/sales/companies/missing"
),
params: { id: "missing" },
context: {},
} as never)
).rejects.toMatchObject({ status: 404 });
});
});
@@ -0,0 +1,38 @@
import { buildAdminSalesDataManagementVM } from "@hivegrid/view-models";
import type { LoaderFunctionArgs } from "react-router";
import { useLoaderData } from "react-router";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { AdminSalesCompaniesPage } from "~/components/screens/admin/sales/data/AdminSalesCompaniesPage";
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminSalesDataOperator(
request,
"admin_sales.crm.read",
async ({ service, canWrite, canExport }) => ({
vm: buildAdminSalesDataManagementVM({
source: await service.listWorkspace(),
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildCompanyHref: (companyId) =>
adminPath(`sales/companies/${encodeURIComponent(companyId)}`, {
mode: "host-aware",
}),
permissions: { canRead: true, canWrite, canExport },
}),
})
);
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesCompaniesRoute(): React.JSX.Element {
const { vm } = useLoaderData<typeof loader>();
return <AdminSalesCompaniesPage vm={vm} />;
}
@@ -0,0 +1,26 @@
import type { LoaderFunctionArgs, MetaFunction } from "react-router";
import { Outlet } from "react-router";
import ServerError from "~/components/ui/errors/ServerError";
import { getTranslations } from "~/locale/i18next.server";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
export async function loader({ request }: LoaderFunctionArgs) {
const { t } = await getTranslations(request);
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
return {
title: `${t("admin.sales.contacts.title")} | ${process.env.APP_NAME}`,
};
}
export const meta: MetaFunction<typeof loader> = ({ data }) => [
{ title: data?.title },
];
export default function AdminSalesContactsLayout(): React.JSX.Element {
return <Outlet />;
}
export function ErrorBoundary(): React.JSX.Element {
return <ServerError />;
}
@@ -0,0 +1,173 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor } = vi.hoisted(() => ({
service: {
getContactDetail: vi.fn(),
createTask: vi.fn(),
completeTask: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
}));
const { telephonyActions } = vi.hoisted(() => ({
telephonyActions: { queueOutboundCall: vi.fn() },
}));
vi.mock(
"~/components/screens/admin/sales/tasks/AdminSalesContactDetailPage",
() => ({ AdminSalesContactDetailPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-tasks.server", () => ({
runAsAdminSalesTaskOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service,
actor,
adminUserId: "admin_1",
timeZone: "Europe/Berlin",
canWrite: true,
})
),
}));
vi.mock("~/services/admin/admin-telephony-connections.server", () => ({
runAsAdminTelephonyOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
actions: telephonyActions,
actor,
adminUserId: "admin_1",
})
),
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./$id";
describe("admin sales contact detail route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.getContactDetail.mockResolvedValue({
id: "contact_1",
firstName: "Ada",
lastName: "Lovelace",
jobTitle: "CTO",
email: "ada@example.test",
phone: "+49 30 123456",
locale: "de-DE",
timeZone: null,
ownerAdminUserId: "admin_1",
company: { id: "company_1", name: "Analytical Engines" },
deals: [],
tasks: [],
activities: [],
});
service.createTask.mockResolvedValue({ id: "task_1" });
});
it("builds a server-side contact timeline behind CRM read permission", async () => {
const result = await loader({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1"
),
params: { id: "contact_1" },
context: {},
} as never);
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(service.getContactDetail).toHaveBeenCalledWith("contact_1");
expect(result.vm).toMatchObject({
id: "contact_1",
name: "Ada Lovelace",
canWrite: true,
});
});
it("validates and creates a recurring contextual task atomically through the service", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1",
{
method: "POST",
body: new URLSearchParams({
intent: "create",
title: "Demo nachfassen",
assignedToAdminUserId: "admin_1",
dueAt: "2026-07-27T09:00:00.000Z",
timeZone: "Europe/Berlin",
priority: "high",
recurrenceFrequency: "weekly",
recurrenceInterval: "1",
reason: "Follow-up am Kontakt angelegt",
}),
}
),
params: { id: "contact_1" },
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.createTask).toHaveBeenCalledWith(
expect.objectContaining({
title: "Demo nachfassen",
contactId: "contact_1",
assignedToAdminUserId: "admin_1",
recurrence: expect.objectContaining({
frequency: "weekly",
interval: 1,
}),
actor: {
adminUserId: "admin_1",
reason: "Follow-up am Kontakt angelegt",
},
})
);
expect(response.status).toBe(303);
});
it("starts a click-to-call request through the telephony permission boundary", async () => {
const response = await action({
request: new Request(
"https://admin.hivegrid.de/sales/contacts/contact_1",
{
method: "POST",
body: new URLSearchParams({ intent: "call" }),
}
),
params: { id: "contact_1" },
context: {},
} as never);
expect(runAsAdminTelephonyOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.phone.call",
expect.any(Function)
);
expect(telephonyActions.queueOutboundCall).toHaveBeenCalledWith(
expect.objectContaining({
adminUserId: "admin_1",
contactId: "contact_1",
})
);
expect(response.status).toBe(303);
});
});
@@ -0,0 +1,205 @@
import {
adminSalesTaskCompleteActionSchema,
adminSalesTaskCreateActionSchema,
adminSalesContactNoteActionSchema,
buildAdminSalesContactDetailVM,
} from "@hivegrid/view-models";
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useTranslation } from "react-i18next";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminSalesContactDetailPage } from "~/components/screens/admin/sales/tasks/AdminSalesContactDetailPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const { locale } = await getTranslations(request);
return runAsAdminSalesTaskOperator(request, "admin_sales.crm.read", async ({ service, adminUserId, timeZone, canWrite }) => {
const contact = await service.getContactDetail(params.id ?? "");
if (!contact) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
return {
currentAdminUserId: adminUserId,
vm: buildAdminSalesContactDetailVM({
now: new Date(),
locale,
defaultTimeZone: timeZone,
contact,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildDealHref: (dealId) =>
adminPath(`sales/deals/${encodeURIComponent(dealId)}`, {
mode: "host-aware",
}),
buildRecordingHref: (recordingId) => adminPath(`sales/calls/recordings/${encodeURIComponent(recordingId)}`, { mode: "host-aware" }),
canWrite,
}),
};
});
}
export async function action({ request, params }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
const contactId = params.id ?? "";
try {
if (intent === "call") {
await runAsAdminTelephonyOperator(request, "admin_sales.phone.call", ({ actions, adminUserId, actor }) =>
actions.queueOutboundCall({
adminUserId,
contactId,
idempotencyKey: randomUUID(),
actor: actor(t("admin.sales.telephony.audit.queue_call")),
})
);
const target = new URL(adminPath("sales/calls", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", "admin.sales.contacts.toast.callQueued");
return Response.redirect(target, 303);
}
if (intent === "add-note") {
const command = adminSalesContactNoteActionSchema.parse({
contactId,
body: form.get("body"),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(request, "admin_sales.crm.write", ({ service, actor }) =>
service.addContactNote({
contactId,
body: command.body,
actor: actor(command.reason),
})
);
const target = new URL(
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
request.url
);
target.searchParams.set("toast", "admin.sales.contacts.toast.noteAdded");
return Response.redirect(target, 303);
}
await runAsAdminSalesTaskOperator(request, "admin_sales.crm.write", async ({ service, actor }) => {
if (intent === "create") {
const command = adminSalesTaskCreateActionSchema.parse({
title: form.get("title"),
description: nullableFormString(form.get("description")),
contactId,
dealId: nullableFormString(form.get("dealId")),
assignedToAdminUserId: form.get("assignedToAdminUserId"),
dueAt: form.get("dueAt"),
timeZone: form.get("timeZone"),
reminderAt: nullableFormString(form.get("reminderAt")),
priority: form.get("priority"),
recurrenceFrequency: nullableFormString(form.get("recurrenceFrequency")),
recurrenceInterval: Number(form.get("recurrenceInterval")),
recurrenceEndsAt: nullableFormString(form.get("recurrenceEndsAt")),
reason: form.get("reason"),
});
await service.createTask({
...command,
description: command.description,
contactId,
dealId: command.dealId,
dueAt: new Date(command.dueAt),
reminderAt: command.reminderAt ? new Date(command.reminderAt) : null,
recurrence: command.recurrenceFrequency
? {
frequency: command.recurrenceFrequency,
interval: command.recurrenceInterval,
endsAt: command.recurrenceEndsAt ? new Date(command.recurrenceEndsAt) : null,
}
: null,
actor: actor(command.reason),
});
return;
}
if (intent === "complete") {
const command = adminSalesTaskCompleteActionSchema.parse({
taskId: form.get("taskId"),
reason: form.get("reason"),
});
await service.completeTask({
taskId: command.taskId,
actor: actor(command.reason),
});
return;
}
throw new Error("INVALID_INTENT");
});
const target = new URL(
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
request.url
);
target.searchParams.set("toast", intent === "complete" ? "admin.sales.tasks.toast.completed" : "admin.sales.tasks.toast.created");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.tasks.errors.actionFailed") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesContactDetailRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm, currentAdminUserId } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const submitIntent = (intent: string, input: Record<string, unknown>) => {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(input)) {
if (value !== null && value !== undefined) form.set(key, String(value));
}
submit(form, { method: "post" });
};
return (
<AdminSalesContactDetailPage
vm={vm}
currentAdminUserId={currentAdminUserId}
backHref={adminPath("sales/deals", { mode: "host-aware" })}
emailComposeHref={
vm.email
? `${adminPath("sales/email/scheduled", { mode: "host-aware" })}?contactId=${encodeURIComponent(vm.id)}&to=${encodeURIComponent(vm.email)}`
: null
}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onCreateTask: (input) => submitIntent("create", input),
onAddNote: (body) =>
submitIntent("add-note", {
body,
reason: t("admin.sales.data.audit.noteCreated"),
}),
onCompleteTask: (taskId) =>
submitIntent("complete", {
taskId,
reason: t("admin.sales.tasks.audit.completed"),
}),
onCall: () => submitIntent("call", {}),
}}
/>
);
}
function nullableFormString(value: FormDataEntryValue | null): string | null {
return typeof value === "string" && value.trim() ? value.trim() : null;
}
@@ -0,0 +1,168 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor, helpers } = vi.hoisted(() => ({
service: {
listWorkspace: vi.fn(),
createTag: vi.fn(),
createCustomField: vi.fn(),
bulkUpdateContacts: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
helpers: {
prepare: vi.fn(),
confirm: vi.fn(),
exportContacts: vi.fn(),
},
}));
vi.mock(
"~/components/screens/admin/sales/data/AdminSalesContactsPage",
() => ({ AdminSalesContactsPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-data.server", () => ({
runAsAdminSalesDataOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service,
actor,
adminUserId: "admin_1",
canWrite: true,
canExport: true,
})
),
prepareAdminSalesContactsImport: helpers.prepare,
confirmAdminSalesContactsImport: helpers.confirm,
requestAdminSalesContactsExport: helpers.exportContacts,
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./index";
describe("admin sales contacts data route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.listWorkspace.mockResolvedValue({
companies: [],
contacts: [],
tags: [],
customFields: [],
importJobs: [],
exportJobs: [],
});
service.createTag.mockResolvedValue({ id: "tag_1" });
});
it("builds the tenantless data-management VM through CRM read", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/sales/contacts"),
params: {},
context: {},
} as never);
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(result.vm).toMatchObject({
status: "empty",
permissions: { canRead: true, canWrite: true, canExport: true },
});
});
it("validates CSRF and creates tags through the smallest write permission", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: new URLSearchParams({
intent: "create-tag",
name: "Kunde",
color: "#2563eb",
reason: "Sales-Tag anlegen",
}),
}),
params: {},
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.createTag).toHaveBeenCalledWith({
name: "Kunde",
color: "#2563eb",
actor: { adminUserId: "admin_1", reason: "Sales-Tag anlegen" },
});
expect(await response.json()).toEqual({
success: "admin.sales.data.feedback.tagCreated",
});
});
it("keeps preview and confirmation separate before queueing", async () => {
helpers.prepare.mockResolvedValue({
job: { id: "import_1", fileName: "kontakte.csv" },
preview: {
headers: ["Vorname", "Nachname"],
rowCount: 1,
suggestedMapping: [
"Vorname=firstName",
"Nachname=lastName",
],
},
});
const previewForm = new FormData();
previewForm.set("intent", "preview-import");
previewForm.set(
"file",
new File(["Vorname,Nachname\nAda,Lovelace\n"], "kontakte.csv", {
type: "text/csv",
})
);
const previewResponse = await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: previewForm,
}),
params: {},
context: {},
} as never);
expect(helpers.prepare).toHaveBeenCalledOnce();
expect(helpers.confirm).not.toHaveBeenCalled();
expect(await previewResponse.json()).toMatchObject({
preview: { jobId: "import_1", rowCount: 1 },
});
await action({
request: new Request("https://admin.hivegrid.de/sales/contacts", {
method: "POST",
body: new URLSearchParams({
intent: "confirm-import",
importJobId: "import_1",
reason: "Geprüften Import starten",
}),
}),
params: {},
context: {},
} as never);
expect(helpers.confirm).toHaveBeenCalledWith(
expect.objectContaining({
importJobId: "import_1",
reason: "Geprüften Import starten",
})
);
});
});
@@ -0,0 +1,92 @@
import { useTranslation } from "react-i18next";
import {
useActionData,
useLoaderData,
useNavigation,
useSubmit,
} from "react-router";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { AdminSalesContactsPage } from "~/components/screens/admin/sales/data/AdminSalesContactsPage";
import {
loadAdminSalesDataRoute,
mutateAdminSalesDataRoute,
type AdminSalesDataActionData,
} from "~/services/admin/admin-sales-data-route.server";
import { appendCSRFToken } from "~/utils/csrf";
export const loader = loadAdminSalesDataRoute;
export const action = mutateAdminSalesDataRoute;
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesContactsRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as AdminSalesDataActionData | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const submitIntent = (
intent: string,
values: Record<string, string | Blob | readonly string[] | number | boolean>
) => {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(values)) {
form.set(
key,
Array.isArray(value)
? JSON.stringify(value)
: value instanceof Blob
? value
: String(value)
);
}
submit(form, { method: "post", encType: "multipart/form-data" });
};
return (
<AdminSalesContactsPage
vm={vm}
preview={actionData?.preview ?? null}
submitting={navigation.state === "submitting"}
successMessage={actionData?.success ?? null}
errorMessage={actionData?.error ?? null}
actions={{
onPreviewImport: (file) => submitIntent("preview-import", { file }),
onConfirmImport: (importJobId) =>
submitIntent("confirm-import", {
importJobId,
reason: t("admin.sales.data.audit.importConfirmed"),
}),
onExport: (contactIds) =>
submitIntent("export", {
contactIds,
reason: t("admin.sales.data.audit.exportRequested"),
}),
onCreateTag: (input) =>
submitIntent("create-tag", {
name: input.name,
color: input.color ?? "",
reason: t("admin.sales.data.audit.tagCreated"),
}),
onCreateCustomField: (input) =>
submitIntent("create-field", {
...input,
options: input.options,
reason: t("admin.sales.data.audit.fieldCreated"),
}),
onBulkUpdate: (input) =>
submitIntent("bulk-update", {
contactIds: input.contactIds,
locale: input.locale ?? "",
localeChanged: input.locale !== null,
addTagIds: input.addTagIds,
reason: t("admin.sales.data.audit.contactsUpdated"),
}),
}}
/>
);
}
@@ -0,0 +1,13 @@
import type { LoaderFunctionArgs } from "react-router";
import { Outlet } from "react-router";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
export async function loader({ request }: LoaderFunctionArgs) {
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
return null;
}
export default function AdminSalesDataJobsLayout(): React.JSX.Element {
return <Outlet />;
}
@@ -0,0 +1,60 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { resolveDownload } = vi.hoisted(() => ({
resolveDownload: vi.fn(
async () => "https://storage.example.test/signed-contact-export"
),
}));
vi.mock("~/services/admin/admin-sales-data.server", () => ({
resolveAdminSalesDataDownload: resolveDownload,
runAsAdminSalesDataOperator: vi.fn(
async (_request, _permission, operation) =>
operation({ adminUserId: "admin_1" })
),
}));
import { runAsAdminSalesDataOperator } from "~/services/admin/admin-sales-data.server";
import { loader } from "./download";
describe("admin sales data job download", () => {
beforeEach(() => {
vi.clearAllMocks();
});
it("requires export permission and redirects only after resolving the owned artifact", async () => {
const response = await loader({
request: new Request(
"https://admin.hivegrid.de/sales/data-jobs/export_1/download?kind=export"
),
params: { id: "export_1" },
context: {},
} as never);
expect(runAsAdminSalesDataOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.export",
expect.any(Function)
);
expect(resolveDownload).toHaveBeenCalledWith({
jobId: "export_1",
kind: "export",
});
expect(response.headers.get("location")).toBe(
"https://storage.example.test/signed-contact-export"
);
});
it("returns 404 semantics for unknown download kinds", async () => {
await expect(
loader({
request: new Request(
"https://admin.hivegrid.de/sales/data-jobs/export_1/download?kind=source"
),
params: { id: "export_1" },
context: {},
} as never)
).rejects.toMatchObject({ status: 404 });
expect(resolveDownload).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,27 @@
import type { LoaderFunctionArgs } from "react-router";
import {
resolveAdminSalesDataDownload,
runAsAdminSalesDataOperator,
} from "~/services/admin/admin-sales-data.server";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const kind = new URL(request.url).searchParams.get("kind");
if (
!params.id ||
(kind !== "import-error" && kind !== "export")
) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
const permission =
kind === "export"
? "admin_sales.crm.export"
: "admin_sales.crm.read";
const url = await runAsAdminSalesDataOperator(
request,
permission,
() => resolveAdminSalesDataDownload({ jobId: params.id!, kind })
);
return Response.redirect(url, 302);
}
@@ -0,0 +1,22 @@
import type { LoaderFunctionArgs, MetaFunction } from "react-router";
import { Outlet } from "react-router";
import ServerError from "~/components/ui/errors/ServerError";
import { getTranslations } from "~/locale/i18next.server";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
export const loader = async ({ request }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
return { title: `${t("admin.sales.deals.title")} | ${process.env.APP_NAME}` };
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminSalesDealsLayout(): React.JSX.Element {
return <Outlet />;
}
export function ErrorBoundary(): React.JSX.Element {
return <ServerError />;
}
@@ -0,0 +1,198 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { actor, createTenant, pipelineService } = vi.hoisted(() => ({
actor: vi.fn((reason: string) => ({
adminUserId: "admin_1",
reason,
})),
createTenant: vi.fn(),
pipelineService: {
linkDealToTenant: vi.fn(),
},
}));
const { telephonyActions } = vi.hoisted(() => ({
telephonyActions: { queueOutboundCall: vi.fn() },
}));
vi.mock("~/components/screens/admin/sales/deals/AdminSalesDealDetailPage", () => ({
AdminSalesDealDetailPage: () => null,
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-pipeline.server", () => ({
runAsAdminSalesPipelineOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service: pipelineService,
actor,
adminUserId: "admin_1",
firstName: "Raffael",
locale: "de-DE",
canWrite: true,
})
),
}));
vi.mock("~/services/admin/admin-sales-tenant.server", () => ({
createAndLinkAdminSalesTenant: createTenant,
}));
vi.mock("~/services/admin/admin-sales-tasks.server", () => ({
runAsAdminSalesTaskOperator: vi.fn(),
}));
vi.mock("~/services/admin/admin-telephony-connections.server", () => ({
runAsAdminTelephonyOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
actions: telephonyActions,
actor,
adminUserId: "admin_1",
})
),
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesPipelineOperator } from "~/services/admin/admin-sales-pipeline.server";
import { createAndLinkAdminSalesTenant } from "~/services/admin/admin-sales-tenant.server";
import { validateCSRFToken } from "~/utils/session.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { action } from "./$id";
function actionRequest(values: Record<string, string>): Request {
return new Request("https://admin.hivegrid.de/sales/deals/deal_1", {
method: "POST",
body: new URLSearchParams({
intent: "tenant-promote",
confirmed: "true",
reason: "Kunde ausdrücklich freigegeben",
...values,
}),
});
}
describe("admin sales deal tenant promotion action", () => {
beforeEach(() => {
vi.clearAllMocks();
pipelineService.linkDealToTenant.mockResolvedValue({
id: "deal_1",
tenantId: "tenant_1",
});
createTenant.mockResolvedValue({
dealId: "deal_1",
tenantId: "tenant_reserved",
});
});
it("starts click-to-call for the selected buying-center contact", async () => {
const response = await action({
request: actionRequest({
intent: "call",
contactId: "contact_1",
}),
params: { id: "deal_1" },
context: {},
} as never);
expect(runAsAdminTelephonyOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.phone.call",
expect.any(Function)
);
expect(telephonyActions.queueOutboundCall).toHaveBeenCalledWith(
expect.objectContaining({
adminUserId: "admin_1",
contactId: "contact_1",
dealId: "deal_1",
})
);
expect(response.status).toBe(303);
});
it("links an existing tenant only after an explicit confirmation", async () => {
const request = actionRequest({
mode: "link_existing",
tenantId: "tenant_1",
});
const response = await action({
request,
params: { id: "deal_1" },
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledWith(request);
expect(runAsAdminSalesPipelineOperator).toHaveBeenCalledWith(
request,
"admin_sales.crm.write",
expect.any(Function)
);
expect(pipelineService.linkDealToTenant).toHaveBeenCalledWith({
dealId: "deal_1",
tenantId: "tenant_1",
actor: {
adminUserId: "admin_1",
reason: "Kunde ausdrücklich freigegeben",
},
});
expect(createAndLinkAdminSalesTenant).not.toHaveBeenCalled();
expect(response.status).toBe(303);
});
it("creates a pending-owner tenant and links it through the dedicated service", async () => {
const request = actionRequest({
mode: "create_new",
tenantName: "Muster GmbH",
tenantSlug: "muster-gmbh",
ownerEmail: "ada@example.test",
ownerFirstName: "Ada",
ownerLastName: "Lovelace",
});
const response = await action({
request,
params: { id: "deal_1" },
context: {},
} as never);
expect(createAndLinkAdminSalesTenant).toHaveBeenCalledWith({
request,
dealId: "deal_1",
tenantName: "Muster GmbH",
tenantSlug: "muster-gmbh",
ownerEmail: "ada@example.test",
ownerFirstName: "Ada",
ownerLastName: "Lovelace",
admin: {
id: "admin_1",
firstName: "Raffael",
locale: "de-DE",
},
actor: {
adminUserId: "admin_1",
reason: "Kunde ausdrücklich freigegeben",
},
});
expect(pipelineService.linkDealToTenant).not.toHaveBeenCalled();
expect(response.status).toBe(303);
});
it("rejects an unconfirmed promotion before any tenant mutation", async () => {
const request = actionRequest({
mode: "link_existing",
tenantId: "tenant_1",
confirmed: "false",
});
const response = await action({
request,
params: { id: "deal_1" },
context: {},
} as never);
expect(response.status).toBe(400);
expect(pipelineService.linkDealToTenant).not.toHaveBeenCalled();
expect(createAndLinkAdminSalesTenant).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,340 @@
import {
adminDealBuyingCenterActionSchema,
adminDealMoveActionSchema,
adminDealTenantPromotionActionSchema,
adminDealUpdateActionSchema,
adminSalesTaskCompleteActionSchema,
adminSalesTaskCreateActionSchema,
buildAdminDealDetailVM,
buildAdminSalesTaskRows,
} from "@hivegrid/view-models";
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useTranslation } from "react-i18next";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminSalesDealDetailPage } from "~/components/screens/admin/sales/deals/AdminSalesDealDetailPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminSalesPipelineOperator } from "~/services/admin/admin-sales-pipeline.server";
import { createAndLinkAdminSalesTenant } from "~/services/admin/admin-sales-tenant.server";
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { runAsAdminTelephonyOperator } from "~/services/admin/admin-telephony-connections.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request, params }: LoaderFunctionArgs) {
const { locale } = await getTranslations(request);
const pipelineResult = await runAsAdminSalesPipelineOperator(request, "admin_sales.crm.read", async ({ service, canWrite }) => {
const deal = await service.getDealDetail(params.id ?? "");
if (!deal) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
const [board, contactOptions, tenantOptions] = await Promise.all([
service.getBoard(deal.pipelineId),
service.listContactOptions(),
service.listTenantOptions(),
]);
if (!board) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
return {
vm: buildAdminDealDetailVM({
now: new Date(),
locale,
deal,
stages: board.stages.map((stage) => ({
id: stage.id,
name: stage.name,
kind: stage.kind,
requiredFields: stage.requiredFields,
})),
lossReasons: board.lossReasons,
contactOptions,
tenantOptions,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildTenantHref: (tenantId) =>
adminPath(`accounts/${encodeURIComponent(tenantId)}`, {
mode: "host-aware",
}),
canWrite,
}),
};
});
const taskResult = await runAsAdminSalesTaskOperator(request, "admin_sales.crm.read", async ({ service, adminUserId, timeZone, canWrite }) => {
const tasks = await service.listForDeal(params.id ?? "");
return {
taskVm: {
tasks: buildAdminSalesTaskRows({
now: new Date(),
locale,
tasks,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildDealHref: (dealId) =>
adminPath(`sales/deals/${encodeURIComponent(dealId)}`, {
mode: "host-aware",
}),
canWrite,
}),
currentAdminUserId: adminUserId,
timeZone,
canWrite,
},
};
});
return { ...pipelineResult, ...taskResult };
}
export async function action({ request, params }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
const dealId = params.id ?? "";
try {
if (intent === "call") {
const contactId = String(form.get("contactId") ?? "");
await runAsAdminTelephonyOperator(request, "admin_sales.phone.call", ({ actions, adminUserId, actor }) =>
actions.queueOutboundCall({
adminUserId,
contactId,
dealId,
idempotencyKey: randomUUID(),
actor: actor(t("admin.sales.telephony.audit.queue_call")),
})
);
const target = new URL(adminPath("sales/calls", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", "admin.sales.deals.toast.callQueued");
return Response.redirect(target, 303);
}
await runAsAdminSalesPipelineOperator(request, "admin_sales.crm.write", async ({ service, actor, adminUserId, firstName, locale }) => {
if (intent === "move") {
const command = adminDealMoveActionSchema.parse({
dealId,
targetStageId: form.get("targetStageId"),
lossReasonId: optionalFormString(form.get("lossReasonId")),
lossReasonNote: optionalFormString(form.get("lossReasonNote")),
reason: form.get("reason"),
});
await service.moveDeal({ ...command, actor: actor(command.reason) });
return;
}
if (intent === "update") {
const command = adminDealUpdateActionSchema.parse({
dealId,
amountCents: nullableInteger(form.get("amountCents")),
currencyCode: form.get("currencyCode"),
expectedCloseDate: optionalFormString(form.get("expectedCloseDate")),
nextStep: optionalFormString(form.get("nextStep")),
nextStepDueAt: optionalFormString(form.get("nextStepDueAt")),
reason: form.get("reason"),
});
await service.updateDeal({
dealId,
amountCents: command.amountCents,
currencyCode: command.currencyCode,
expectedCloseDate: command.expectedCloseDate ? new Date(`${command.expectedCloseDate}T00:00:00.000Z`) : null,
nextStep: command.nextStep,
nextStepDueAt: command.nextStepDueAt ? new Date(command.nextStepDueAt) : null,
actor: actor(command.reason),
});
return;
}
if (intent === "buying-center") {
const command = adminDealBuyingCenterActionSchema.parse({
dealId,
contactIds: form.getAll("contactId").map(String),
primaryContactId: optionalFormString(form.get("primaryContactId")),
roles: parseRoles(form.get("roles")),
reason: form.get("reason"),
});
await service.replaceDealContacts({
dealId,
contactIds: command.contactIds,
primaryContactId: command.primaryContactId,
roles: command.roles,
actor: actor(command.reason),
});
return;
}
if (intent === "tenant-promote") {
const command = adminDealTenantPromotionActionSchema.parse({
dealId,
mode: form.get("mode"),
tenantId: optionalFormString(form.get("tenantId")),
tenantName: optionalFormString(form.get("tenantName")),
tenantSlug: optionalFormString(form.get("tenantSlug")),
ownerEmail: optionalFormString(form.get("ownerEmail")),
ownerFirstName: optionalFormString(form.get("ownerFirstName")),
ownerLastName: optionalFormString(form.get("ownerLastName")),
confirmed: form.get("confirmed") === "true",
reason: form.get("reason"),
});
const promotionActor = actor(command.reason);
if (command.mode === "link_existing") {
await service.linkDealToTenant({
dealId,
tenantId: command.tenantId!,
actor: promotionActor,
});
} else {
await createAndLinkAdminSalesTenant({
request,
dealId,
tenantName: command.tenantName!,
tenantSlug: command.tenantSlug!,
ownerEmail: command.ownerEmail!,
ownerFirstName: command.ownerFirstName!,
ownerLastName: command.ownerLastName!,
admin: {
id: adminUserId,
firstName,
locale,
},
actor: promotionActor,
});
}
return;
}
if (intent === "task-create") {
const command = adminSalesTaskCreateActionSchema.parse({
title: form.get("title"),
description: optionalFormString(form.get("description")),
contactId: optionalFormString(form.get("contactId")),
dealId,
assignedToAdminUserId: form.get("assignedToAdminUserId"),
dueAt: form.get("dueAt"),
timeZone: form.get("timeZone"),
reminderAt: optionalFormString(form.get("reminderAt")),
priority: form.get("priority"),
recurrenceFrequency: optionalFormString(form.get("recurrenceFrequency")),
recurrenceInterval: Number(form.get("recurrenceInterval")),
recurrenceEndsAt: optionalFormString(form.get("recurrenceEndsAt")),
reason: form.get("reason"),
});
await runAsAdminSalesTaskOperator(request, "admin_sales.crm.write", ({ service: taskService, actor: taskActor }) =>
taskService.createTask({
...command,
dueAt: new Date(command.dueAt),
reminderAt: command.reminderAt ? new Date(command.reminderAt) : null,
recurrence: command.recurrenceFrequency
? {
frequency: command.recurrenceFrequency,
interval: command.recurrenceInterval,
endsAt: command.recurrenceEndsAt ? new Date(command.recurrenceEndsAt) : null,
}
: null,
actor: taskActor(command.reason),
})
);
return;
}
if (intent === "task-complete") {
const command = adminSalesTaskCompleteActionSchema.parse({
taskId: form.get("taskId"),
reason: form.get("reason"),
});
await runAsAdminSalesTaskOperator(request, "admin_sales.crm.write", ({ service: taskService, actor: taskActor }) =>
taskService.completeTask({
taskId: command.taskId,
actor: taskActor(command.reason),
})
);
return;
}
throw new Error("INVALID_INTENT");
});
const messageKeyByIntent: Record<string, string> = {
move: "admin.sales.deals.toast.moved",
update: "admin.sales.deals.toast.updated",
"buying-center": "admin.sales.deals.toast.buyingCenterSaved",
"tenant-promote": "admin.sales.deals.toast.tenantLinked",
"task-create": "admin.sales.tasks.toast.created",
"task-complete": "admin.sales.tasks.toast.completed",
};
const target = new URL(adminPath(`sales/deals/${encodeURIComponent(dealId)}`, { mode: "host-aware" }), request.url);
target.searchParams.set("toast", messageKeyByIntent[intent] ?? "admin.sales.deals.toast.updated");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.deals.errors.actionFailed") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesDealDetailRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm, taskVm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const primaryEmailContact = vm.contacts.find((contact) => contact.isPrimary && contact.email);
function submitInput(intent: string, input: Record<string, unknown>) {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(input)) {
if (value === null || value === undefined) continue;
if (key === "contactIds" && Array.isArray(value)) {
value.forEach((entry) => form.append("contactId", String(entry)));
} else if (key === "roles") {
form.set("roles", JSON.stringify(value));
} else {
form.set(key, String(value));
}
}
submit(form, { method: "post" });
}
return (
<AdminSalesDealDetailPage
vm={vm}
taskVm={taskVm}
backHref={`${adminPath("sales/deals", { mode: "host-aware" })}?pipeline=${encodeURIComponent(vm.pipelineId)}`}
emailComposeHref={
primaryEmailContact
? `${adminPath("sales/email/scheduled", { mode: "host-aware" })}?dealId=${encodeURIComponent(vm.id)}&contactId=${encodeURIComponent(primaryEmailContact.id)}&to=${encodeURIComponent(primaryEmailContact.email!)}`
: null
}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onMove: (input) => submitInput("move", input),
onUpdate: (input) => submitInput("update", input),
onReplaceBuyingCenter: (input) => submitInput("buying-center", { ...input, contactIds: input.contactIds }),
onPromoteTenant: (input) => submitInput("tenant-promote", input),
onCreateTask: (input) => submitInput("task-create", input),
onCompleteTask: (taskId) =>
submitInput("task-complete", {
taskId,
reason: t("admin.sales.tasks.audit.completed"),
}),
onCall: (contactId) => submitInput("call", { contactId }),
}}
/>
);
}
function optionalFormString(value: FormDataEntryValue | null): string | null {
return typeof value === "string" && value.trim() ? value.trim() : null;
}
function nullableInteger(value: FormDataEntryValue | null): number | null {
if (typeof value !== "string" || value.trim() === "") return null;
const parsed = Number(value);
return Number.isSafeInteger(parsed) ? parsed : Number.NaN;
}
function parseRoles(value: FormDataEntryValue | null): Record<string, string> {
if (typeof value !== "string") return {};
const parsed: unknown = JSON.parse(value);
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, string] => typeof entry[1] === "string"));
}
@@ -0,0 +1,122 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor } = vi.hoisted(() => ({
service: {
listPipelines: vi.fn(),
getBoard: vi.fn(),
moveDeal: vi.fn(),
createPipeline: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
}));
vi.mock("@hivegrid/ui-app", () => ({ toAdminSalesDealsProps: (vm: unknown) => vm }));
vi.mock("~/components/screens/admin/sales/deals/AdminSalesDealPipelinePage", () => ({ AdminSalesDealPipelinePage: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ locale: "de-DE", t: (key: string) => key })),
}));
vi.mock("~/services/admin/admin-sales-pipeline.server", () => ({
runAsAdminSalesPipelineOperator: vi.fn(async (_request, _permission, operation) =>
operation({ service, actor, canWrite: true, canConfigure: true })
),
}));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
import { runAsAdminSalesPipelineOperator } from "~/services/admin/admin-sales-pipeline.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./index";
describe("admin sales deals route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.listPipelines.mockResolvedValue([{ id: "pipeline_1", name: "SaaS Sales", isDefault: true }]);
service.getBoard.mockResolvedValue({
pipeline: { id: "pipeline_1", name: "SaaS Sales", description: null },
stages: [],
lossReasons: [],
});
service.moveDeal.mockResolvedValue({ id: "deal_1" });
});
it("builds the pipeline VM behind the smallest read permission", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/sales/deals?pipeline=pipeline_1"),
params: {},
context: {},
} as never);
expect(runAsAdminSalesPipelineOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(service.getBoard).toHaveBeenCalledWith("pipeline_1");
expect(result.vm).toMatchObject({
status: "ready",
pipelineId: "pipeline_1",
permissions: { canWrite: true, canConfigure: true },
});
});
it("validates CSRF and moves a deal through the write-gated domain service", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/deals", {
method: "POST",
body: new URLSearchParams({
intent: "move",
dealId: "deal_1",
targetStageId: "stage_demo",
reason: "Deal nach Demo verschoben",
}),
}),
params: {},
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesPipelineOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.moveDeal).toHaveBeenCalledWith(
expect.objectContaining({
dealId: "deal_1",
targetStageId: "stage_demo",
actor: { adminUserId: "admin_1", reason: "Deal nach Demo verschoben" },
})
);
expect(response.status).toBe(303);
});
it("creates the default pipeline with request-locale labels", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/deals", {
method: "POST",
body: new URLSearchParams({ intent: "create-default-pipeline" }),
}),
params: {},
context: {},
} as never);
expect(service.createPipeline).toHaveBeenCalledWith(
expect.objectContaining({
name: "admin.sales.pipelineSettings.defaults.pipelineName",
stages: expect.arrayContaining([
expect.objectContaining({ name: "admin.sales.pipelineSettings.defaults.stages.quote" }),
expect.objectContaining({ name: "admin.sales.pipelineSettings.defaults.stages.won" }),
]),
lossReasons: [
"admin.sales.pipelineSettings.defaults.lossReasons.noBudget",
"admin.sales.pipelineSettings.defaults.lossReasons.noNeed",
"admin.sales.pipelineSettings.defaults.lossReasons.competitor",
"admin.sales.pipelineSettings.defaults.lossReasons.timing",
"admin.sales.pipelineSettings.defaults.lossReasons.badFit",
"admin.sales.pipelineSettings.defaults.lossReasons.noResponse",
],
})
);
expect(response.status).toBe(303);
});
});
@@ -0,0 +1,140 @@
import { ADMIN_SAAS_PIPELINE_BLUEPRINT, type AdminPipelineStageInput } from "@hivegrid/db/admin-sales-pipeline.server";
import { adminDealMoveActionSchema, buildAdminDealPipelineVM } from "@hivegrid/view-models";
import { toAdminSalesDealsProps } from "@hivegrid/ui-app";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigate, useNavigation, useSubmit } from "react-router";
import { AdminSalesDealPipelinePage } from "~/components/screens/admin/sales/deals/AdminSalesDealPipelinePage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { runAsAdminSalesPipelineOperator } from "~/services/admin/admin-sales-pipeline.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
const { locale } = await getTranslations(request);
return runAsAdminSalesPipelineOperator(request, "admin_sales.crm.read", async ({ service, canWrite, canConfigure }) => {
const pipelineId = new URL(request.url).searchParams.get("pipeline");
const [pipelines, board] = await Promise.all([service.listPipelines(), service.getBoard(pipelineId)]);
return {
vm: toAdminSalesDealsProps(
buildAdminDealPipelineVM({
now: new Date(),
locale,
pipelines,
board,
buildDealHref: (dealId) => adminPath(`sales/deals/${encodeURIComponent(dealId)}`, { mode: "host-aware" }),
permissions: { canRead: true, canWrite, canConfigure },
})
),
};
});
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
try {
if (intent === "move") {
const command = adminDealMoveActionSchema.parse({
dealId: form.get("dealId"),
targetStageId: form.get("targetStageId"),
lossReasonId: optionalFormString(form.get("lossReasonId")),
lossReasonNote: optionalFormString(form.get("lossReasonNote")),
reason: form.get("reason"),
});
await runAsAdminSalesPipelineOperator(request, "admin_sales.crm.write", ({ service, actor }) =>
service.moveDeal({ ...command, actor: actor(command.reason) })
);
} else if (intent === "create-default-pipeline") {
await runAsAdminSalesPipelineOperator(request, "admin_sales.crm.assign", ({ service, actor }) =>
service.createPipeline({
name: t("admin.sales.pipelineSettings.defaults.pipelineName"),
description: t("admin.sales.pipelineSettings.defaultPipelineDescription"),
isDefault: true,
stages: ADMIN_SAAS_PIPELINE_BLUEPRINT.map(
(stage, position): AdminPipelineStageInput => ({
name: t(`admin.sales.pipelineSettings.defaults.stages.${stage.key}`),
position,
kind: stage.kind,
probabilityBasisPoints: stage.probabilityBasisPoints,
agingThresholdDays: stage.agingThresholdDays,
requiredFields:
stage.key === "demo"
? ["nextStep"]
: stage.key === "quote"
? ["amountCents", "expectedCloseDate", "nextStep"]
: stage.key === "won"
? ["amountCents", "companyId", "primaryContactId"]
: stage.key === "lost"
? ["lossReasonId"]
: [],
})
),
lossReasons: ["noBudget", "noNeed", "competitor", "timing", "badFit", "noResponse"].map((key) =>
t(`admin.sales.pipelineSettings.defaults.lossReasons.${key}`)
),
actor: actor(t("admin.sales.deals.audit.defaultPipeline")),
})
);
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
const target = new URL(adminPath("sales/deals", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", intent === "move" ? "admin.sales.deals.toast.moved" : "admin.sales.deals.toast.defaultPipelineCreated");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.deals.errors.actionFailed") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesDealsIndexRoute(): React.JSX.Element {
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const navigate = useNavigate();
const submit = useSubmit();
const submitting = navigation.state === "submitting";
return (
<AdminSalesDealPipelinePage
vm={vm}
submitting={submitting}
errorMessage={actionData?.error ?? null}
actions={{
onSwitchPipeline: (pipelineId) => {
const search = new URLSearchParams({ pipeline: pipelineId });
void navigate(`${adminPath("sales/deals", { mode: "host-aware" })}?${search}`);
},
onMove: (input) => {
const form = appendCSRFToken(new FormData());
form.set("intent", "move");
form.set("dealId", input.dealId);
form.set("targetStageId", input.targetStageId);
if (input.lossReasonId) form.set("lossReasonId", input.lossReasonId);
if (input.lossReasonNote) form.set("lossReasonNote", input.lossReasonNote);
form.set("reason", input.reason);
submit(form, { method: "post" });
},
onCreateDefaultPipeline: () => {
const form = appendCSRFToken(new FormData());
form.set("intent", "create-default-pipeline");
submit(form, { method: "post" });
},
onOpenSettings: () => void navigate(adminPath("settings/pipelines", { mode: "host-aware" })),
}}
/>
);
}
function optionalFormString(value: FormDataEntryValue | null): string | null {
return typeof value === "string" && value.trim() ? value.trim() : null;
}
@@ -0,0 +1,109 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
attachment: vi.fn(),
audit: vi.fn(),
sign: vi.fn(),
}));
vi.mock("@hivegrid/db/admin-sales-core.server", () => ({
writeAdminSalesAudit: mocks.audit,
}));
vi.mock("~/utils/db.server", () => ({
db: {
adminEmailAttachment: { findFirst: mocks.attachment },
},
}));
vi.mock("~/utils/integrations/mediaSigning.server", () => ({
createMediaDownloadUrl: mocks.sign,
}));
vi.mock("~/utils/integrations/storageService", () => ({
resolveStorageBucket: () => "hivegrid-files",
}));
vi.mock("~/services/admin/admin-email-connections.server", () => ({
runAsAdminEmailOperator: async (
_request: Request,
permissions: readonly string[],
operation: (context: unknown) => Promise<unknown>
) => {
expect(permissions).toEqual([
"admin_sales.email.send",
"admin_sales.communication.read_all",
]);
return operation({
adminUserId: "manager",
canReadAllCommunication: true,
actor: (reason: string) => ({
adminUserId: "manager",
email: "manager@example.test",
reason,
}),
});
},
}));
import { loader } from "./$attachmentId";
describe("admin email attachment download", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.attachment.mockResolvedValue({
id: "attachment-b",
adminUserId: "sales-b",
messageId: "message-b",
filename: "angebot.pdf",
storageKey: "admin-email/sales-b/angebot.pdf",
});
mocks.sign.mockResolvedValue("https://storage.example.test/signed");
});
it("audits a foreign team attachment before returning a short-lived redirect", async () => {
const response = await loader({
request: new Request(
"https://admin.example.test/sales/email/attachments/attachment-b"
),
params: { attachmentId: "attachment-b" },
context: {},
} as never);
expect(mocks.attachment).toHaveBeenCalledWith(
expect.objectContaining({
where: {
id: "attachment-b",
storageBucket: "hivegrid-files",
},
})
);
expect(mocks.audit).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
action: "admin.sales.email.attachment.downloaded",
targetId: "attachment-b",
after: {
dataOwnerAdminUserId: "sales-b",
messageId: "message-b",
foreignAccess: true,
},
})
);
expect(response).toMatchObject({ status: 302 });
expect((response as Response).headers.get("location")).toBe(
"https://storage.example.test/signed"
);
});
it("returns 404 when RLS or owner scope hides the attachment", async () => {
mocks.attachment.mockResolvedValue(null);
await expect(
loader({
request: new Request(
"https://admin.example.test/sales/email/attachments/missing"
),
params: { attachmentId: "missing" },
context: {},
} as never)
).rejects.toMatchObject({ status: 404 });
expect(mocks.audit).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,67 @@
import { writeAdminSalesAudit } from "@hivegrid/db/admin-sales-core.server";
import type { LoaderFunctionArgs } from "react-router";
import { runAsAdminEmailOperator } from "~/services/admin/admin-email-connections.server";
import { db } from "~/utils/db.server";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
import { createMediaDownloadUrl } from "~/utils/integrations/mediaSigning.server";
import { resolveStorageBucket } from "~/utils/integrations/storageService";
export async function loader({ params, request }: LoaderFunctionArgs) {
const attachmentId = params.attachmentId;
if (!attachmentId) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
return runAsAdminEmailOperator(
request,
[
"admin_sales.email.send",
"admin_sales.communication.read_all",
],
async (context) => {
const attachment = await db.adminEmailAttachment.findFirst({
where: {
id: attachmentId,
...(context.canReadAllCommunication
? {}
: { adminUserId: context.adminUserId }),
storageBucket: resolveStorageBucket(),
},
select: {
id: true,
adminUserId: true,
messageId: true,
filename: true,
storageKey: true,
},
});
if (!attachment) {
throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
}
await writeAdminSalesAudit(db, {
actor: context.actor("E-Mail-Anhang heruntergeladen"),
action: "admin.sales.email.attachment.downloaded",
targetType: "AdminEmailAttachment",
targetId: attachment.id,
after: {
dataOwnerAdminUserId: attachment.adminUserId,
messageId: attachment.messageId,
foreignAccess:
attachment.adminUserId !== context.adminUserId,
},
});
const location = await createMediaDownloadUrl({
key: attachment.storageKey,
filename: attachment.filename,
ttlSeconds: 60,
});
return new Response(null, {
status: 302,
headers: {
"Cache-Control": "private, no-store",
Location: location,
},
});
}
);
}
@@ -0,0 +1,237 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
runAs: vi.fn(async (_request, _permission, operation) =>
operation({
adminUserId: "admin-1",
actor: (reason: string) => ({
adminUserId: "admin-1",
email: "raffael@hivegrid.de",
reason,
}),
})
),
apply: vi.fn(),
inbox: vi.fn(),
templates: vi.fn(),
scheduled: vi.fn(),
domains: vi.fn(),
validateCsrf: vi.fn(),
}));
vi.mock("~/components/screens/admin/sales/email/AdminEmailInboxPage", () => ({ AdminEmailInboxPage: () => null }));
vi.mock("~/components/screens/admin/sales/email/AdminEmailTemplatesPage", () => ({ AdminEmailTemplatesPage: () => null }));
vi.mock("~/components/screens/admin/sales/email/AdminEmailScheduledPage", () => ({ AdminEmailScheduledPage: () => null }));
vi.mock("~/components/screens/admin/sales/email/AdminEmailDomainsPage", () => ({ AdminEmailDomainsPage: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
}));
vi.mock("~/services/admin/admin-email-connections.server", () => ({
runAsAdminEmailOperator: mocks.runAs,
}));
vi.mock("~/services/admin/admin-email-workspace.server", () => ({
adminEmailWorkspaceHrefs: vi.fn(() => ({})),
applyAdminEmailWorkspaceAction: mocks.apply,
readAdminEmailInbox: mocks.inbox,
readAdminEmailTemplates: mocks.templates,
readAdminEmailScheduled: mocks.scheduled,
readAdminEmailDomains: mocks.domains,
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: mocks.validateCsrf,
}));
import { action as inboxAction, loader as inboxLoader } from "./inbox";
import { action as scheduledAction, loader as scheduledLoader } from "./scheduled";
import { action as templatesAction, loader as templatesLoader } from "./templates";
import { action as domainsAction, loader as domainsLoader } from "../settings/sending-domains";
describe("admin email workspace routes", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.inbox.mockResolvedValue({
stats: { threads: 0, unread: 0, assignmentQueue: 0 },
threads: [],
selectedThread: null,
assignmentOptions: { contacts: [], deals: [] },
});
mocks.templates.mockResolvedValue({
templates: [],
snippets: [],
signature: null,
});
mocks.scheduled.mockResolvedValue({
outboundLocked: true,
policy: null,
scheduled: [],
bulkRuns: [],
reminders: [],
mailboxes: [],
contacts: [],
});
mocks.domains.mockResolvedValue({
domains: [],
bccAddresses: [],
tracking: {
enabled: false,
liveOpenEnabled: false,
retentionDays: 180,
},
});
});
it("loads every screen through its smallest admin permission", async () => {
await inboxLoader(loaderArgs("/sales/email/inbox?thread=thread-1"));
expect(mocks.inbox).toHaveBeenCalledWith(expect.objectContaining({ adminUserId: "admin-1" }), "thread-1");
expect(mocks.runAs).toHaveBeenLastCalledWith(
expect.any(Request),
[
"admin_sales.email.send",
"admin_sales.communication.read_all",
],
expect.any(Function)
);
await templatesLoader(loaderArgs("/sales/email/templates"));
expect(mocks.runAs).toHaveBeenLastCalledWith(
expect.any(Request),
"admin_sales.email.send",
expect.any(Function)
);
await scheduledLoader(loaderArgs("/sales/email/scheduled"));
expect(mocks.runAs).toHaveBeenLastCalledWith(
expect.any(Request),
[
"admin_sales.email.send",
"admin_sales.communication.read_all",
],
expect.any(Function)
);
await domainsLoader(loaderArgs("/sales/settings/sending-domains"));
expect(mocks.runAs).toHaveBeenLastCalledWith(expect.any(Request), "admin_sales.email.track", expect.any(Function));
});
it("validates and applies an explicit message assignment", async () => {
const response = await inboxAction(
actionArgs("/sales/email/inbox", {
intent: "assign-message",
messageId: "message-1",
contactId: "contact-1",
dealId: null,
})
);
expect(mocks.validateCsrf).toHaveBeenCalledOnce();
expect(mocks.apply).toHaveBeenCalledWith(
expect.objectContaining({ adminUserId: "admin-1" }),
expect.objectContaining({
intent: "assign-message",
contactId: "contact-1",
})
);
expect(response).toEqual({
intent: "assign-message",
ok: true,
messageKey: "admin.sales.email.toast.assignmentSaved",
});
});
it("uses bulk-send permission for a personalized list", async () => {
const response = await scheduledAction(
actionArgs("/sales/email/scheduled", {
intent: "queue-bulk-email",
mailboxId: "mailbox-1",
name: "Demo Follow-up",
contactIds: ["contact-1", "contact-2"],
subjectTemplate: "Hallo {{first_name}}",
bodyTemplate: "Guten Tag {{full_name}}",
scheduledFor: "2026-07-25T08:00:00.000Z",
timeZone: "Europe/Berlin",
noReplyAfterDays: 3,
idempotencyKey: "bulk-1",
})
);
expect(mocks.runAs).toHaveBeenLastCalledWith(expect.any(Request), "admin_sales.email.bulk_send", expect.any(Function));
expect(mocks.apply).toHaveBeenCalledWith(
expect.any(Object),
expect.objectContaining({
intent: "queue-bulk-email",
contactIds: ["contact-1", "contact-2"],
})
);
expect(response).toEqual({
intent: "queue-bulk-email",
ok: true,
messageKey: "admin.sales.email.toast.bulkQueued",
});
});
it("accepts template and domain actions and rejects cross-route intents", async () => {
await expect(
templatesAction(
actionArgs("/sales/email/templates", {
intent: "save-snippet",
shortcut: "intro",
title: "Einleitung",
content: "Guten Tag",
})
)
).resolves.toEqual({
intent: "save-snippet",
ok: true,
messageKey: "admin.sales.email.toast.snippetSaved",
});
await expect(
domainsAction(
actionArgs("/sales/settings/sending-domains", {
intent: "save-domain",
domain: "hivegrid.de",
spfRecordName: "hivegrid.de",
spfExpectedValue: "v=spf1 -all",
dkimRecordName: "mail._domainkey.hivegrid.de",
dkimExpectedValue: "k=rsa; p=key",
})
)
).resolves.toEqual({
intent: "save-domain",
ok: true,
messageKey: "admin.sales.email.toast.domainSaved",
});
const rejected = await templatesAction(
actionArgs("/sales/email/templates", {
intent: "assign-message",
messageId: "message-1",
contactId: "contact-1",
dealId: null,
})
);
expect(rejected).toBeInstanceOf(Response);
expect((rejected as Response).status).toBe(400);
});
});
function loaderArgs(path: string) {
return {
request: new Request(`https://admin.hivegrid.de${path}`),
params: {},
context: {},
} as never;
}
function actionArgs(path: string, payload: object) {
const form = new FormData();
form.set("payload", JSON.stringify(payload));
return {
request: new Request(`https://admin.hivegrid.de${path}`, {
method: "POST",
body: form,
}),
params: {},
context: {},
} as never;
}
@@ -0,0 +1,83 @@
import { adminEmailWorkspaceActionSchema, buildAdminEmailInboxVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigate, useNavigation, useSubmit } from "react-router";
import { AdminEmailInboxPage } from "~/components/screens/admin/sales/email/AdminEmailInboxPage";
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, readAdminEmailInbox } 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) {
const selected = new URL(request.url).searchParams.get("thread");
return runAsAdminEmailOperator(
request,
[
"admin_sales.email.send",
"admin_sales.communication.read_all",
],
async (context) => ({
vm: buildAdminEmailInboxVM(await readAdminEmailInbox(context, selected)),
hrefs: adminEmailWorkspaceHrefs(),
})
);
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const parsed = adminEmailWorkspaceActionSchema.safeParse(parsePayload(form));
if (!parsed.success || parsed.data.intent !== "assign-message") {
return Response.json({ error: t("admin.sales.email.errors.invalidAction") }, { status: 400 });
}
try {
await runAsAdminEmailOperator(request, "admin_sales.email.send", (context) => applyAdminEmailWorkspaceAction(context, parsed.data));
return { intent: parsed.data.intent, ok: true, messageKey: "admin.sales.email.toast.assignmentSaved" } satisfies ActionData;
} catch {
return Response.json({ error: t("admin.sales.email.errors.assignmentFailed") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminEmailInboxRoute() {
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const navigate = useNavigate();
const submit = useSubmit();
useSaveToast(actionData?.ok ? actionData : undefined);
return (
<AdminEmailInboxPage
vm={vm}
hrefs={hrefs}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onOpenThread: (threadId) => navigate(`?thread=${encodeURIComponent(threadId)}`),
onAssign: (input) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent: "assign-message", ...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,98 @@
import { adminEmailWorkspaceActionSchema, buildAdminEmailScheduledVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSearchParams, useSubmit } from "react-router";
import { AdminEmailScheduledPage } from "~/components/screens/admin/sales/email/AdminEmailScheduledPage";
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, readAdminEmailScheduled } 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 };
const SCHEDULED_SUCCESS_KEYS: Readonly<Record<string, string>> = {
"queue-email": "admin.sales.email.toast.emailQueued",
"queue-bulk-email": "admin.sales.email.toast.bulkQueued",
"save-policy": "admin.sales.email.toast.policySaved",
};
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminEmailOperator(
request,
[
"admin_sales.email.send",
"admin_sales.communication.read_all",
],
async (context) => ({
vm: buildAdminEmailScheduledVM(await readAdminEmailScheduled(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 !== "queue-email" && parsed.data.intent !== "queue-bulk-email" && parsed.data.intent !== "save-policy")) {
return Response.json({ error: t("admin.sales.email.errors.invalidAction") }, { status: 400 });
}
try {
await runAsAdminEmailOperator(
request,
parsed.data.intent === "save-policy" || parsed.data.intent === "queue-bulk-email" ? "admin_sales.email.bulk_send" : "admin_sales.email.send",
(context) => applyAdminEmailWorkspaceAction(context, parsed.data)
);
return { intent: parsed.data.intent, ok: true, messageKey: SCHEDULED_SUCCESS_KEYS[parsed.data.intent] } satisfies ActionData;
} catch {
return Response.json({ error: t("admin.sales.email.errors.saveFailed") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminEmailScheduledRoute() {
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const [searchParams] = useSearchParams();
const submit = useSubmit();
useSaveToast(actionData?.ok ? actionData : undefined);
const submitIntent = (intent: string, input: object) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent, ...input }));
submit(form, { method: "post" });
};
return (
<AdminEmailScheduledPage
vm={vm}
hrefs={hrefs}
composeDefaults={{
contactId: searchParams.get("contactId"),
dealId: searchParams.get("dealId"),
toAddress: searchParams.get("to") ?? "",
}}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onQueueEmail: (input) => submitIntent("queue-email", input),
onQueueBulkEmail: (input) => submitIntent("queue-bulk-email", input),
onSavePolicy: (input) => submitIntent("save-policy", input),
}}
/>
);
}
function parsePayload(form: FormData) {
try {
return JSON.parse(String(form.get("payload") ?? "{}")) as unknown;
} catch {
return null;
}
}
@@ -0,0 +1,81 @@
import { adminEmailWorkspaceActionSchema, buildAdminEmailTemplatesVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminEmailTemplatesPage } from "~/components/screens/admin/sales/email/AdminEmailTemplatesPage";
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, readAdminEmailTemplates } 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 };
const TEMPLATE_SUCCESS_KEYS: Readonly<Record<string, string>> = {
"save-template": "admin.sales.email.toast.templateSaved",
"save-snippet": "admin.sales.email.toast.snippetSaved",
"save-signature": "admin.sales.email.toast.signatureSaved",
};
export async function loader({ request }: LoaderFunctionArgs) {
return runAsAdminEmailOperator(request, "admin_sales.email.send", async (context) => ({
vm: buildAdminEmailTemplatesVM(await readAdminEmailTemplates(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 || !["save-template", "save-snippet", "save-signature"].includes(parsed.data.intent)) {
return Response.json({ error: t("admin.sales.email.errors.invalidAction") }, { status: 400 });
}
try {
await runAsAdminEmailOperator(request, "admin_sales.email.send", (context) => applyAdminEmailWorkspaceAction(context, parsed.data));
return { intent: parsed.data.intent, ok: true, messageKey: TEMPLATE_SUCCESS_KEYS[parsed.data.intent] } satisfies ActionData;
} catch {
return Response.json({ error: t("admin.sales.email.errors.saveFailed") }, { status: 400 });
}
}
export function HydrateFallback() {
return <AdminSalesLoadingPage />;
}
export default function AdminEmailTemplatesRoute() {
const { vm, hrefs } = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigation = useNavigation();
const submit = useSubmit();
useSaveToast(actionData?.ok ? actionData : undefined);
const submitIntent = (intent: string, input: object) => {
const form = appendCSRFToken(new FormData());
form.set("payload", JSON.stringify({ intent, ...input }));
submit(form, { method: "post" });
};
return (
<AdminEmailTemplatesPage
vm={vm}
hrefs={hrefs}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error}
actions={{
onSaveTemplate: (input) => submitIntent("save-template", input),
onSaveSnippet: (input) => submitIntent("save-snippet", input),
onSaveSignature: (input) => submitIntent("save-signature", input),
}}
/>
);
}
function parsePayload(form: FormData) {
try {
return JSON.parse(String(form.get("payload") ?? "{}")) as unknown;
} catch {
return null;
}
}
@@ -0,0 +1,76 @@
import { useTranslation } from "react-i18next";
import {
useActionData,
useLoaderData,
useNavigation,
useSubmit,
} from "react-router";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { AdminSalesContactsPage } from "~/components/screens/admin/sales/data/AdminSalesContactsPage";
import {
loadAdminSalesDataRoute,
mutateAdminSalesDataRoute,
type AdminSalesDataActionData,
} from "~/services/admin/admin-sales-data-route.server";
import { appendCSRFToken } from "~/utils/csrf";
export const loader = loadAdminSalesDataRoute;
export const action = mutateAdminSalesDataRoute;
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesImportExportRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as AdminSalesDataActionData | undefined;
const navigation = useNavigation();
const submit = useSubmit();
const submitIntent = (
intent: string,
values: Record<string, string | Blob | readonly string[]>
) => {
const form = appendCSRFToken(new FormData());
form.set("intent", intent);
for (const [key, value] of Object.entries(values)) {
form.set(
key,
Array.isArray(value)
? JSON.stringify(value)
: value instanceof Blob
? value
: String(value)
);
}
submit(form, { method: "post", encType: "multipart/form-data" });
};
return (
<AdminSalesContactsPage
vm={vm}
view="import-export"
preview={actionData?.preview ?? null}
submitting={navigation.state === "submitting"}
successMessage={actionData?.success ?? null}
errorMessage={actionData?.error ?? null}
actions={{
onPreviewImport: (file) => submitIntent("preview-import", { file }),
onConfirmImport: (importJobId) =>
submitIntent("confirm-import", {
importJobId,
reason: t("admin.sales.data.audit.importConfirmed"),
}),
onExport: (contactIds) =>
submitIntent("export", {
contactIds,
reason: t("admin.sales.data.audit.exportRequested"),
}),
onCreateTag: () => undefined,
onCreateCustomField: () => undefined,
onBulkUpdate: () => undefined,
}}
/>
);
}
@@ -0,0 +1,51 @@
import { describe, expect, it } from "vitest";
import {
ADMIN_SALES_SETTINGS_FALLBACK_TITLE_KEY,
ADMIN_SALES_SETTINGS_TITLE_KEYS,
resolveAdminSalesSettingsTitleKey,
} from "~/services/admin/admin-sales-settings-titles";
describe("resolveAdminSalesSettingsTitleKey", () => {
it("names the requested child instead of a sibling", () => {
// Regression guard: every child inherited the branch layout's title, so
// telephony and fields-tags announced themselves as "Pipeline konfigurieren"
// in the document title and in the header breadcrumb.
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/telephony")).toBe("admin.sales.navigation.telephonySettings");
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/fields-tags")).toBe("admin.sales.navigation.fieldsTags");
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/pipelines")).toBe("admin.sales.navigation.pipelineSettings");
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/leads")).toBe("admin.sales.navigation.leadSettings");
});
it("resolves host-aware and admin-prefixed pathnames alike", () => {
expect(resolveAdminSalesSettingsTitleKey("/admin/sales/settings/telephony")).toBe("admin.sales.navigation.telephonySettings");
});
it("keeps a nested child on its parent's title until it maps its own", () => {
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/telephony/aircall")).toBe("admin.sales.navigation.telephonySettings");
});
it("matches whole segments only", () => {
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/telephony-legacy")).toBe(ADMIN_SALES_SETTINGS_FALLBACK_TITLE_KEY);
});
it("falls back to the section name for the branch root and unknown children", () => {
expect(resolveAdminSalesSettingsTitleKey("/sales/settings")).toBe(ADMIN_SALES_SETTINGS_FALLBACK_TITLE_KEY);
expect(resolveAdminSalesSettingsTitleKey("/sales/settings/not-built-yet")).toBe(ADMIN_SALES_SETTINGS_FALLBACK_TITLE_KEY);
});
it("maps every route file in the branch", async () => {
const { readdirSync } = await import("node:fs");
const { dirname, join } = await import("node:path");
const { fileURLToPath } = await import("node:url");
const branchDir = join(dirname(fileURLToPath(import.meta.url)), "settings");
const routeSlugs = readdirSync(branchDir, { withFileTypes: true })
.filter((entry) => entry.isFile() && entry.name.endsWith(".tsx"))
.map((entry) => entry.name.replace(/\.tsx$/, ""));
const mappedSlugs = new Set(ADMIN_SALES_SETTINGS_TITLE_KEYS.map(([path]) => path));
expect(routeSlugs.length).toBeGreaterThan(0);
expect(routeSlugs.filter((slug) => !mappedSlugs.has(slug))).toEqual([]);
});
});
@@ -0,0 +1,31 @@
import type { LoaderFunctionArgs, MetaFunction } from "react-router";
import { Outlet } from "react-router";
import ServerError from "~/components/ui/errors/ServerError";
import { AdminSettingsShell } from "~/components/screens/admin/settings/AdminSettingsShell";
import { getTranslations } from "~/locale/i18next.server";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
import { resolveAdminSalesSettingsTitleKey } from "~/services/admin/admin-sales-settings-titles";
export const loader = async ({ request }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
// This layout is the deepest titled match for the whole branch, so the title
// has to follow the requested child instead of naming one of its siblings.
const titleKey = resolveAdminSalesSettingsTitleKey(new URL(request.url).pathname);
return { title: `${t(titleKey)} | ${process.env.APP_NAME}` };
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminSalesSettingsLayout(): React.JSX.Element {
return (
<AdminSettingsShell>
<Outlet />
</AdminSettingsShell>
);
}
export function ErrorBoundary(): React.JSX.Element {
return <ServerError />;
}
@@ -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");
}
@@ -0,0 +1,26 @@
import type { LoaderFunctionArgs, MetaFunction } from "react-router";
import { Outlet } from "react-router";
import ServerError from "~/components/ui/errors/ServerError";
import { getTranslations } from "~/locale/i18next.server";
import { requireAdminIdentityPermission } from "~/services/admin/admin-identity.server";
export async function loader({ request }: LoaderFunctionArgs) {
const { t } = await getTranslations(request);
await requireAdminIdentityPermission(request, "admin_sales.crm.read");
return {
title: `${t("admin.sales.tasks.today.title")} | ${process.env.APP_NAME}`,
};
}
export const meta: MetaFunction<typeof loader> = ({ data }) => [
{ title: data?.title },
];
export default function AdminSalesTasksLayout(): React.JSX.Element {
return <Outlet />;
}
export function ErrorBoundary(): React.JSX.Element {
return <ServerError />;
}
@@ -0,0 +1,102 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const { service, actor } = vi.hoisted(() => ({
service: {
listToday: vi.fn(),
completeTask: vi.fn(),
},
actor: vi.fn((reason: string) => ({ adminUserId: "admin_1", reason })),
}));
vi.mock(
"~/components/screens/admin/sales/tasks/AdminSalesTodayPage",
() => ({ AdminSalesTodayPage: () => null })
);
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
locale: "de-DE",
t: (key: string) => key,
})),
}));
vi.mock("~/services/admin/admin-sales-tasks.server", () => ({
getAdminSalesTaskDayRange: () => ({
start: new Date("2026-07-23T22:00:00.000Z"),
end: new Date("2026-07-24T22:00:00.000Z"),
}),
runAsAdminSalesTaskOperator: vi.fn(
async (_request, _permission, operation) =>
operation({
service,
actor,
adminUserId: "admin_1",
timeZone: "Europe/Berlin",
canWrite: true,
})
),
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./today";
describe("admin sales today route", () => {
beforeEach(() => {
vi.clearAllMocks();
service.listToday.mockResolvedValue([]);
service.completeTask.mockResolvedValue({ task: {}, nextTask: null });
});
it("loads only the signed-in admin's task queue", async () => {
const result = await loader({
request: new Request("https://admin.hivegrid.de/sales/tasks/today"),
params: {},
context: {},
} as never);
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.read",
expect.any(Function)
);
expect(service.listToday).toHaveBeenCalledWith(
expect.objectContaining({
assignedToAdminUserId: "admin_1",
timeZone: "Europe/Berlin",
})
);
expect(result.vm).toMatchObject({
status: "empty",
permissions: { canRead: true, canWrite: true },
});
});
it("validates CSRF and completes through the write-gated task service", async () => {
const response = await action({
request: new Request("https://admin.hivegrid.de/sales/tasks/today", {
method: "POST",
body: new URLSearchParams({
taskId: "task_1",
reason: "Aufgabe heute erledigt",
}),
}),
params: {},
context: {},
} as never);
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminSalesTaskOperator).toHaveBeenCalledWith(
expect.any(Request),
"admin_sales.crm.write",
expect.any(Function)
);
expect(service.completeTask).toHaveBeenCalledWith({
taskId: "task_1",
actor: { adminUserId: "admin_1", reason: "Aufgabe heute erledigt" },
});
expect(response.status).toBe(303);
});
});
@@ -0,0 +1,93 @@
import { adminSalesTaskCompleteActionSchema, buildAdminSalesTodayVM } from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { useTranslation } from "react-i18next";
import { useActionData, useLoaderData, useNavigation, useSubmit } from "react-router";
import { AdminSalesTodayPage } from "~/components/screens/admin/sales/tasks/AdminSalesTodayPage";
import { AdminSalesLoadingPage } from "~/components/screens/admin/sales/AdminSalesLoadingPage";
import { getTranslations } from "~/locale/i18next.server";
import { getAdminSalesTaskDayRange, runAsAdminSalesTaskOperator } from "~/services/admin/admin-sales-tasks.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { appendCSRFToken } from "~/utils/csrf";
import { validateCSRFToken } from "~/utils/session.server";
export async function loader({ request }: LoaderFunctionArgs) {
const { locale } = await getTranslations(request);
return runAsAdminSalesTaskOperator(request, "admin_sales.crm.read", async ({ service, adminUserId, timeZone, canWrite }) => {
const now = new Date();
const tasks = await service.listToday({
assignedToAdminUserId: adminUserId,
now,
timeZone,
});
const { start } = getAdminSalesTaskDayRange(now, timeZone);
return {
vm: buildAdminSalesTodayVM({
now,
todayStart: start,
locale,
timeZone,
tasks,
buildContactHref: (contactId) =>
adminPath(`sales/contacts/${encodeURIComponent(contactId)}`, {
mode: "host-aware",
}),
buildDealHref: (dealId) =>
adminPath(`sales/deals/${encodeURIComponent(dealId)}`, {
mode: "host-aware",
}),
permissions: { canRead: true, canWrite },
}),
};
});
}
export async function action({ request }: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
try {
const command = adminSalesTaskCompleteActionSchema.parse({
taskId: form.get("taskId"),
reason: form.get("reason"),
});
await runAsAdminSalesTaskOperator(request, "admin_sales.crm.write", ({ service, actor }) =>
service.completeTask({
taskId: command.taskId,
actor: actor(command.reason),
})
);
const target = new URL(adminPath("sales/tasks/today", { mode: "host-aware" }), request.url);
target.searchParams.set("toast", "admin.sales.tasks.toast.completed");
return Response.redirect(target, 303);
} catch {
return Response.json({ error: t("admin.sales.tasks.errors.actionFailed") }, { status: 400 });
}
}
export function HydrateFallback(): React.JSX.Element {
return <AdminSalesLoadingPage />;
}
export default function AdminSalesTodayRoute(): React.JSX.Element {
const { t } = useTranslation();
const { vm } = useLoaderData<typeof loader>();
const actionData = useActionData() as { readonly error?: string } | undefined;
const navigation = useNavigation();
const submit = useSubmit();
return (
<AdminSalesTodayPage
vm={vm}
submitting={navigation.state === "submitting"}
errorMessage={actionData?.error ?? null}
actions={{
onComplete: (taskId) => {
const form = appendCSRFToken(new FormData());
form.set("taskId", taskId);
form.set("reason", t("admin.sales.tasks.audit.completed"));
submit(form, { method: "post" });
},
}}
/>
);
}