259 lines
10 KiB
TypeScript
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" }),
|
|
}}
|
|
/>
|
|
);
|
|
}
|