Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/admin/leads/$id.tsx
T

259 lines
10 KiB
TypeScript

import {
adminLeadAdvancedMutationFormSchema,
adminLeadMutationFormSchema,
buildAdminLeadDetailVM,
} from "@hivegrid/view-models";
import { PlatformLeadAdminError } from "@hivegrid/db/platform-leads-admin.server";
import { useTranslation } from "react-i18next";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { redirect, useActionData, useLoaderData, useNavigate, useNavigation, useSubmit } from "react-router";
import { AdminPlatformLeadDetailPage } from "~/components/screens/admin/leads/AdminPlatformLeadDetailPage";
import { getTranslations } from "~/locale/i18next.server";
import {
assertPlatformLeadVisibleToOperator,
listPlatformLeadAssignees,
platformLeadNotFound,
requirePlatformLeadWrite,
runAsPlatformLeadOperator,
} from "~/services/admin/platform-leads.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
type ActionData = { readonly error: string };
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const leadId = params.id?.trim();
if (!leadId) throw platformLeadNotFound();
const data = await runAsPlatformLeadOperator(request, async ({ access, service }) => {
const [lead, assignees] = await Promise.all([service.getLead({ leadId }), listPlatformLeadAssignees()]);
if (!lead) throw platformLeadNotFound();
assertPlatformLeadVisibleToOperator(lead, access);
const assigneeLabels = new Map(assignees.map((option) => [option.id, option.label]));
return {
vm: buildAdminLeadDetailVM({
lead: {
id: lead.id,
firstName: lead.firstName,
lastName: lead.lastName,
email: lead.email,
phone: lead.phone,
company: lead.company,
message: lead.message,
status: lead.status,
sourceId: lead.source.id,
sourceDisplayName: lead.source.displayName,
sourceDetail: lead.sourceDetail,
externalId: lead.externalId,
assignedToAdminUserId: lead.assignedToAdminUserId,
assigneeLabel: lead.assignedToAdminUserId ? (assigneeLabels.get(lead.assignedToAdminUserId) ?? null) : null,
duplicateHintOfLeadId: lead.duplicateHintOfLeadId,
capturedAt: lead.capturedAt,
createdAt: lead.createdAt,
updatedAt: lead.updatedAt,
archivedAt: lead.archivedAt,
attribution: {
utmSource: lead.utmSource,
utmMedium: lead.utmMedium,
utmCampaign: lead.utmCampaign,
utmTerm: lead.utmTerm,
utmContent: lead.utmContent,
referrer: lead.referrer,
landingPage: lead.landingPage,
},
qualification: lead.qualification,
duplicateCandidates: lead.duplicateCandidates,
conversion: lead.conversion,
activities: lead.activities.map((activity) => ({
id: activity.id,
type: activity.type,
actorAdminUserId: activity.actorAdminUserId,
actorLabel: activity.actorAdminUserId ? (assigneeLabels.get(activity.actorAdminUserId) ?? null) : null,
note: typeof activity.payload.note === "string" ? activity.payload.note : null,
createdAt: activity.createdAt,
})),
},
assigneeOptions: assignees,
permissions: {
canWrite: access.canWrite,
canAssign: access.canAdmin,
canMerge: access.canMerge,
},
}),
feedback: (() => {
const feedback = new URL(request.url).searchParams.get("feedback");
return feedback === "created" || feedback === "updated" ? feedback : null;
})(),
};
});
const session = await getUserInfo(request);
return { ...data, csrf: session.csrf ?? "" };
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const { t } = await getTranslations(request);
const leadId = params.id?.trim();
if (!leadId) throw platformLeadNotFound();
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
const baseParsed = adminLeadMutationFormSchema.safeParse({
intent,
status: form.get("status"),
assignedToAdminUserId:
form.get("assignedToAdminUserId") === "unassigned"
? null
: form.get("assignedToAdminUserId"),
note: form.get("note"),
});
const advancedParsed = adminLeadAdvancedMutationFormSchema.safeParse({
intent,
provider: form.get("provider"),
companyName: form.get("companyName"),
domain: form.get("domain"),
website: form.get("website"),
region: form.get("region"),
countryCode: form.get("countryCode"),
industry: form.get("industry"),
employeeRange: form.get("employeeRange"),
candidateId: form.get("candidateId"),
survivorLeadId: form.get("survivorLeadId"),
mergedLeadId: form.get("mergedLeadId"),
firstName: form.get("firstName"),
lastName: form.get("lastName"),
dealTitle: form.get("dealTitle"),
ownerAdminUserId: form.get("ownerAdminUserId"),
amountCents: form.get("amountCents"),
expectedCloseDate: form.get("expectedCloseDate"),
nextStep: form.get("nextStep"),
});
const reason = String(form.get("reason") ?? "").trim();
if ((!baseParsed.success && !advancedParsed.success) || (intent !== "note" && reason.length < 5)) {
return Response.json({ error: t("admin.platformLeads.errors.invalidForm") } satisfies ActionData, { status: 400 });
}
try {
let redirectLeadId = leadId;
await runAsPlatformLeadOperator(request, async ({ access, service, advancedService }) => {
const parsed = baseParsed.success ? baseParsed.data : advancedParsed.success ? advancedParsed.data : null;
if (!parsed) throw new Error("Lead action could not be parsed.");
requirePlatformLeadWrite(access);
const audit = access.audit(parsed.intent === "note" ? parsed.note : reason);
const advancedActor = {
adminUserId: audit.actorAdminUserId,
email: audit.actorEmail,
reason: audit.reason,
requestId: audit.requestId,
ip: audit.actorIp,
userAgent: audit.actorUserAgent,
};
const visibility = access.canReadAll ? {} : { requiredAssigneeAdminUserId: access.actorAdminUserId };
switch (parsed.intent) {
case "status":
await service.updateStatus({ leadId, status: parsed.status, ...visibility, ...audit });
return;
case "assign":
await service.assignLead({ leadId, assignedToAdminUserId: parsed.assignedToAdminUserId, ...visibility, ...audit });
return;
case "note":
await service.addNote({ leadId, note: parsed.note, ...visibility, ...audit });
return;
case "archive":
await service.archiveLead({ leadId, ...visibility, ...audit });
return;
case "restore":
await service.restoreLead({ leadId, ...visibility, ...audit });
return;
case "auto-assign":
await advancedService.autoAssignLead({ leadId, actor: advancedActor });
return;
case "score":
await advancedService.scoreLead({ leadId, actor: advancedActor });
return;
case "detect-duplicates":
await advancedService.detectDuplicates({ leadId, actor: advancedActor });
return;
case "enrich":
await advancedService.enrichLead({
leadId,
result: {
provider: parsed.provider,
companyName: parsed.companyName,
domain: parsed.domain,
website: parsed.website,
region: parsed.region,
countryCode: parsed.countryCode,
industry: parsed.industry,
employeeRange: parsed.employeeRange,
},
actor: advancedActor,
});
return;
case "dismiss-duplicate":
await advancedService.dismissDuplicate({
candidateId: parsed.candidateId,
reason,
actor: advancedActor,
});
return;
case "merge":
redirectLeadId = (
await advancedService.mergeLeads({
candidateId: parsed.candidateId,
survivorLeadId: parsed.survivorLeadId,
mergedLeadId: parsed.mergedLeadId,
reason,
actor: advancedActor,
})
).survivorLeadId;
return;
case "convert":
await advancedService.convertLead({
leadId,
companyName: parsed.companyName,
firstName: parsed.firstName,
lastName: parsed.lastName,
dealTitle: parsed.dealTitle,
ownerAdminUserId: parsed.ownerAdminUserId,
amountCents: parsed.amountCents,
expectedCloseDate: parsed.expectedCloseDate,
nextStep: parsed.nextStep,
actor: advancedActor,
});
return;
}
});
return redirect(`${adminPath(`leads/${redirectLeadId}`, { mode: "host-aware" })}?feedback=updated`);
} catch (error) {
if (error instanceof Response) throw error;
if (error instanceof PlatformLeadAdminError && error.code === "NOT_FOUND") throw platformLeadNotFound();
return Response.json({ error: t("admin.platformLeads.errors.actionFailed") } satisfies ActionData, { status: 400 });
}
};
export default function AdminPlatformLeadDetailRoute(): React.JSX.Element {
const data = useLoaderData<typeof loader>();
const actionData = useActionData<ActionData>();
const navigate = useNavigate();
const navigation = useNavigation();
const submit = useSubmit();
const { t } = useTranslation();
return (
<AdminPlatformLeadDetailPage
vm={data.vm}
csrf={data.csrf}
submitting={navigation.state === "submitting"}
feedback={{
success: data.feedback ? t(`admin.platformLeads.feedback.${data.feedback}`) : undefined,
error: actionData?.error,
}}
actions={{
onBack: () => void navigate(adminPath("leads", { mode: "host-aware" })),
onSubmit: (input) => void submit(input, { method: "post" }),
}}
/>
);
}