Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/services/admin/admin-sales-data-route.server.ts
T

224 lines
7.3 KiB
TypeScript

import {
adminSalesBulkContactsActionSchema,
adminSalesCustomFieldActionSchema,
adminSalesExportActionSchema,
adminSalesImportConfirmActionSchema,
adminSalesTagActionSchema,
buildAdminSalesDataManagementVM,
type AdminSalesImportPreviewVM,
} from "@hivegrid/view-models";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import {
confirmAdminSalesContactsImport,
prepareAdminSalesContactsImport,
requestAdminSalesContactsExport,
runAsAdminSalesDataOperator,
} from "~/services/admin/admin-sales-data.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
export type AdminSalesDataActionData = {
readonly success?: string;
readonly error?: string;
readonly preview?: AdminSalesImportPreviewVM;
};
export async function loadAdminSalesDataRoute({
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",
}),
buildImportErrorHref: (jobId) =>
adminPath(
`sales/data-jobs/${encodeURIComponent(jobId)}/download?kind=import-error`,
{ mode: "host-aware" }
),
buildExportHref: (jobId) =>
adminPath(
`sales/data-jobs/${encodeURIComponent(jobId)}/download?kind=export`,
{ mode: "host-aware" }
),
permissions: { canRead: true, canWrite, canExport },
}),
})
);
}
export async function mutateAdminSalesDataRoute({
request,
}: ActionFunctionArgs) {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
try {
if (intent === "preview-import") {
const file = form.get("file");
if (!(file instanceof File)) throw new Error("INVALID_FILE");
return runAsAdminSalesDataOperator(
request,
"admin_sales.crm.write",
async (context) => {
const prepared = await prepareAdminSalesContactsImport({
file,
reason: t("admin.sales.data.audit.importPrepared"),
context,
});
return Response.json({
preview: {
jobId: prepared.job.id,
fileName: prepared.job.fileName,
rowCount: prepared.preview.rowCount,
headers: [...prepared.preview.headers],
mapping: [...prepared.preview.suggestedMapping],
},
} satisfies AdminSalesDataActionData);
}
);
}
if (intent === "confirm-import") {
const command = adminSalesImportConfirmActionSchema.parse({
importJobId: form.get("importJobId"),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(
request,
"admin_sales.crm.write",
(context) =>
confirmAdminSalesContactsImport({
importJobId: command.importJobId,
reason: command.reason,
context,
})
);
return Response.json({
success: t("admin.sales.data.feedback.importQueued"),
} satisfies AdminSalesDataActionData);
}
if (intent === "create-tag") {
const command = adminSalesTagActionSchema.parse({
name: form.get("name"),
color: nullableString(form.get("color")),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(
request,
"admin_sales.crm.write",
({ service, actor }) => {
const { reason, ...data } = command;
return service.createTag({ ...data, actor: actor(reason) });
}
);
return Response.json({
success: t("admin.sales.data.feedback.tagCreated"),
} satisfies AdminSalesDataActionData);
}
if (intent === "create-field") {
const command = adminSalesCustomFieldActionSchema.parse({
target: form.get("target"),
key: form.get("key"),
label: form.get("label"),
type: form.get("type"),
options: parseStringArray(form.get("options")),
required: form.get("required") === "true",
position: Number(form.get("position")),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(
request,
"admin_sales.crm.write",
({ service, actor }) => {
const { reason, ...data } = command;
return service.createCustomField({
...data,
actor: actor(reason),
});
}
);
return Response.json({
success: t("admin.sales.data.feedback.fieldCreated"),
} satisfies AdminSalesDataActionData);
}
if (intent === "bulk-update") {
const localeWasProvided = form.get("localeChanged") === "true";
const command = adminSalesBulkContactsActionSchema.parse({
contactIds: parseStringArray(form.get("contactIds")),
locale: nullableString(form.get("locale")),
addTagIds: parseStringArray(form.get("addTagIds")),
removeTagIds: [],
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(
request,
"admin_sales.crm.write",
({ service, actor }) =>
service.bulkUpdateContacts({
contactIds: command.contactIds,
...(localeWasProvided ? { locale: command.locale } : {}),
addTagIds: command.addTagIds,
removeTagIds: command.removeTagIds,
actor: actor(command.reason),
})
);
return Response.json({
success: t("admin.sales.data.feedback.contactsUpdated"),
} satisfies AdminSalesDataActionData);
}
if (intent === "export") {
const command = adminSalesExportActionSchema.parse({
contactIds: parseStringArray(form.get("contactIds")),
reason: form.get("reason"),
});
await runAsAdminSalesDataOperator(
request,
"admin_sales.crm.export",
(context) =>
requestAdminSalesContactsExport({
contactIds: command.contactIds,
reason: command.reason,
context,
})
);
return Response.json({
success: t("admin.sales.data.feedback.exportQueued"),
} satisfies AdminSalesDataActionData);
}
throw new Error("INVALID_INTENT");
} catch {
return Response.json(
{ error: t("admin.sales.data.errors.actionFailed") } satisfies AdminSalesDataActionData,
{ status: 400 }
);
}
}
function parseStringArray(value: FormDataEntryValue | null): string[] {
if (typeof value !== "string") return [];
const parsed: unknown = JSON.parse(value);
if (
!Array.isArray(parsed) ||
parsed.some((entry) => typeof entry !== "string")
) {
throw new Error("INVALID_ARRAY");
}
return parsed;
}
function nullableString(value: FormDataEntryValue | null): string | null {
return typeof value === "string" && value.trim() ? value.trim() : null;
}