413 lines
16 KiB
JavaScript
413 lines
16 KiB
JavaScript
// File: server/rr/rr-register-socket-events.js
|
|
// RR events aligned to Fortellis flow with Fortellis-style logging via CreateRRLogEvent
|
|
|
|
const CreateRRLogEvent = require("../rr/rr-logger-event");
|
|
const { rrCombinedSearch, rrGetAdvisors, rrGetParts } = require("../rr/rr-lookup");
|
|
const { QueryJobData } = require("../rr/rr-job-helpers");
|
|
const { exportJobToRR } = require("../rr/rr-job-export");
|
|
const CdkCalculateAllocations = require("../cdk/cdk-calculate-allocations").default;
|
|
const { createRRCustomer } = require("../rr/rr-customers");
|
|
|
|
const { GraphQLClient } = require("graphql-request");
|
|
const queries = require("../graphql-client/queries");
|
|
|
|
const getTransactionType = (jobid) => `rr:${jobid}`;
|
|
const defaultRRTTL = 60 * 60;
|
|
|
|
// ---------------- cache keys (RR) ----------------
|
|
const RRCacheEnums = {
|
|
txEnvelope: "RR.txEnvelope",
|
|
JobData: "RR.JobData",
|
|
SelectedCustomer: "RR.SelectedCustomer",
|
|
AdvisorNo: "RR.AdvisorNo",
|
|
VINCandidates: "RR.VINCandidates",
|
|
SelectedVin: "RR.SelectedVin",
|
|
ExportResult: "RR.ExportResult"
|
|
};
|
|
|
|
// ---------------- utils ----------------
|
|
function resolveJobId(explicit, payload, job) {
|
|
return explicit || payload?.jobId || payload?.jobid || job?.id || job?.jobId || job?.jobid || null;
|
|
}
|
|
const digitsOnly = (s) => String(s || "").replace(/\D/g, "");
|
|
|
|
const makeVehicleSearchPayloadFromJob = (job) => {
|
|
const vin = job?.v_vin;
|
|
if (vin) return { kind: "vin", vin: String(vin).trim(), maxResults: 50 };
|
|
const plate = job?.plate_no;
|
|
if (plate) return { kind: "license", license: String(plate).trim(), maxResults: 50 };
|
|
return null;
|
|
};
|
|
|
|
const makeCustomerSearchPayloadFromJob = (job) => {
|
|
const phone = job?.ownr_ph1 || job?.ownr_ph2;
|
|
const d = digitsOnly(phone);
|
|
if (d.length >= 7) return { kind: "phone", phone: d, maxResults: 50 };
|
|
|
|
const firstName = job?.ownr_fn;
|
|
const lastName = job?.ownr_ln;
|
|
const company = job?.ownr_co_nm;
|
|
|
|
if (firstName || lastName) {
|
|
const nameObj = {};
|
|
if (firstName) nameObj.fname = String(firstName).trim();
|
|
if (lastName) nameObj.lname = String(lastName).trim();
|
|
return { kind: "name", name: nameObj, maxResults: 50 };
|
|
}
|
|
if (company) {
|
|
return { kind: "name", name: { name: String(company).trim() }, maxResults: 50 };
|
|
}
|
|
|
|
const vin = job?.v_vin;
|
|
if (vin) return { kind: "vin", vin: String(vin).trim(), maxResults: 50 };
|
|
|
|
return null;
|
|
};
|
|
|
|
// Normalize candidates FE expects: { custNo, name } and flag vinOwner when sourced via VIN
|
|
const normalizeCustomerCandidates = (res, { markVinOwner = false } = {}) => {
|
|
const blocks = Array.isArray(res?.data) ? res.data : Array.isArray(res) ? res : [];
|
|
const out = [];
|
|
for (const blk of blocks) {
|
|
const serv = Array.isArray(blk?.ServVehicle) ? blk.ServVehicle : [];
|
|
const custNos = serv.map((sv) => sv?.VehicleServInfo?.CustomerNo).filter(Boolean);
|
|
|
|
const nci = blk?.NameContactId;
|
|
const ind = nci?.NameId?.IndName;
|
|
const bus = nci?.NameId?.BusName;
|
|
const personal = [ind?.FirstName || ind?.FName, ind?.LastName || ind?.LName].filter(Boolean).join(" ").trim();
|
|
const company = bus?.CompanyName || bus?.BName;
|
|
const name = (personal || company || "").trim();
|
|
|
|
for (const custNo of custNos) {
|
|
out.push({
|
|
custNo: String(custNo),
|
|
name: name || `Customer ${custNo}`,
|
|
...(markVinOwner ? { vinOwner: true } : {})
|
|
});
|
|
}
|
|
}
|
|
const seen = new Set();
|
|
return out.filter((c) => {
|
|
const key = String(c.custNo || "").trim();
|
|
if (!key || seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
};
|
|
|
|
async function getSessionOrSocket(redisHelpers, socket) {
|
|
let sess = null;
|
|
try {
|
|
sess = await redisHelpers.getSessionData(socket.id);
|
|
} catch {
|
|
//
|
|
}
|
|
const bodyshopId = sess?.bodyshopId ?? socket.bodyshopId;
|
|
const email = sess?.email ?? socket.user?.email;
|
|
if (!bodyshopId) throw new Error("No bodyshopId (session/socket)");
|
|
return { bodyshopId, email, sess };
|
|
}
|
|
|
|
async function getBodyshopForSocket({ bodyshopId, socket }) {
|
|
const endpoint = process.env.GRAPHQL_ENDPOINT;
|
|
if (!endpoint) throw new Error("GRAPHQL_ENDPOINT not configured");
|
|
const token = (socket?.data && socket.data.authToken) || (socket?.handshake?.auth && socket.handshake.auth.token);
|
|
const client = new GraphQLClient(endpoint, {});
|
|
const res = await client
|
|
.setHeaders({ Authorization: `Bearer ${token}` })
|
|
.request(queries.GET_BODYSHOP_BY_ID, { id: bodyshopId });
|
|
const bodyshop = res?.bodyshops_by_pk;
|
|
if (!bodyshop) throw new Error(`Bodyshop not found: ${bodyshopId}`);
|
|
return bodyshop;
|
|
}
|
|
|
|
function readAdvisorNo(payload, cached) {
|
|
const v =
|
|
(payload?.txEnvelope?.advisorNo != null && String(payload.txEnvelope.advisorNo)) ||
|
|
(payload?.advisorNo != null && String(payload.advisorNo)) ||
|
|
(cached != null && String(cached)) ||
|
|
null;
|
|
return v && v.trim() !== "" ? v : null;
|
|
}
|
|
|
|
// VIN + Name merge; keep vinOwner flag if any source came from VIN
|
|
async function rrMultiCustomerSearch(bodyshop, job, socket) {
|
|
const queries = [];
|
|
const vehQ = makeVehicleSearchPayloadFromJob(job);
|
|
if (vehQ) queries.push({ q: vehQ, fromVin: vehQ.kind === "vin" });
|
|
const custQ = makeCustomerSearchPayloadFromJob(job);
|
|
if (custQ) queries.push({ q: custQ, fromVin: false });
|
|
|
|
if (!queries.length) return [];
|
|
|
|
const all = [];
|
|
for (const { q, fromVin } of queries) {
|
|
try {
|
|
CreateRRLogEvent(socket, "DEBUG", `{RR-SEARCH} Executing ${q.kind} query`, { q });
|
|
const res = await rrCombinedSearch(bodyshop, q);
|
|
const norm = normalizeCustomerCandidates(res, { markVinOwner: !!fromVin });
|
|
all.push(...norm);
|
|
} catch (e) {
|
|
CreateRRLogEvent(socket, "WARN", "Multi-search subquery failed", { kind: q.kind, error: e.message });
|
|
}
|
|
}
|
|
|
|
const byCust = new Map();
|
|
for (const c of all) {
|
|
const key = c?.custNo && String(c.custNo).trim();
|
|
if (!key) continue;
|
|
const prev = byCust.get(key);
|
|
if (!prev) byCust.set(key, c);
|
|
else if (c.vinOwner && !prev.vinOwner) byCust.set(key, { ...prev, vinOwner: true });
|
|
}
|
|
return Array.from(byCust.values());
|
|
}
|
|
|
|
// ---------------- register handlers ----------------
|
|
function registerRREvents({ socket, redisHelpers }) {
|
|
// ---------- Lookup passthrough ----------
|
|
socket.on("rr-lookup-combined", async ({ jobid, params } = {}, cb) => {
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-lookup-combined: begin", { jobid, params });
|
|
const res = await rrCombinedSearch(bodyshop, params || {});
|
|
const normalized = normalizeCustomerCandidates(res);
|
|
const rid = resolveJobId(jobid, { jobid }, null);
|
|
cb?.({ jobid: rid, data: normalized });
|
|
socket.emit("rr-select-customer", normalized);
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-lookup-combined: emitted rr-select-customer", { count: normalized.length });
|
|
} catch (e) {
|
|
CreateRRLogEvent(socket, "ERROR", "RR combined lookup error", { error: e.message, jobid });
|
|
cb?.({ jobid, error: e.message });
|
|
}
|
|
});
|
|
|
|
// ---------- Advisors ----------
|
|
socket.on("rr-get-advisors", async (args = {}, ack) => {
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-get-advisors: begin", { args });
|
|
const res = await rrGetAdvisors(bodyshop, args);
|
|
ack?.({ ok: true, result: res });
|
|
socket.emit("rr-get-advisors:result", res);
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-get-advisors: success", {
|
|
count: Array.isArray(res) ? res.length : undefined
|
|
});
|
|
} catch (err) {
|
|
CreateRRLogEvent(socket, "ERROR", "rr-get-advisors: failed", { error: err?.message });
|
|
ack?.({ ok: false, error: err?.message || "get advisors failed" });
|
|
}
|
|
});
|
|
|
|
// ---------- Parts ----------
|
|
socket.on("rr-get-parts", async (args = {}, ack) => {
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-get-parts: begin", { args });
|
|
const res = await rrGetParts(bodyshop, args);
|
|
ack?.({ ok: true, result: res });
|
|
socket.emit("rr-get-parts:result", res);
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-get-parts: success", {
|
|
count: Array.isArray(res) ? res.length : undefined
|
|
});
|
|
} catch (err) {
|
|
CreateRRLogEvent(socket, "ERROR", "rr-get-parts: failed", { error: err?.message });
|
|
ack?.({ ok: false, error: err?.message || "get parts failed" });
|
|
}
|
|
});
|
|
|
|
// ================= Fortellis-style two-step export =================
|
|
// 1) Stage export -> search -> emit rr-select-customer
|
|
socket.on("rr-export-job", async ({ jobid, jobId, txEnvelope } = {}) => {
|
|
const rid = resolveJobId(jobid || jobId, { jobId, jobid }, null);
|
|
try {
|
|
if (!rid) throw new Error("RR export: jobid required");
|
|
CreateRRLogEvent(socket, "DEBUG", `{1} Received RR export request`, { jobid: rid });
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
getTransactionType(rid),
|
|
RRCacheEnums.txEnvelope,
|
|
txEnvelope || {},
|
|
defaultRRTTL
|
|
);
|
|
CreateRRLogEvent(socket, "DEBUG", `{1.1} Cached txEnvelope`, { hasTxEnvelope: !!txEnvelope });
|
|
|
|
const job = await QueryJobData({ redisHelpers }, rid);
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
getTransactionType(rid),
|
|
RRCacheEnums.JobData,
|
|
job,
|
|
defaultRRTTL
|
|
);
|
|
CreateRRLogEvent(socket, "DEBUG", `{1.2} Cached JobData`, { vin: job?.v_vin, ro: job?.ro_number });
|
|
|
|
const adv = readAdvisorNo(
|
|
{ txEnvelope },
|
|
await redisHelpers.getSessionTransactionData(socket.id, getTransactionType(rid), RRCacheEnums.AdvisorNo)
|
|
);
|
|
if (adv) {
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
getTransactionType(rid),
|
|
RRCacheEnums.AdvisorNo,
|
|
String(adv),
|
|
defaultRRTTL
|
|
);
|
|
CreateRRLogEvent(socket, "DEBUG", `{1.3} Cached advisorNo`, { advisorNo: String(adv) });
|
|
}
|
|
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
CreateRRLogEvent(socket, "DEBUG", `{2} Running multi-search (VIN + Name)`);
|
|
const candidates = await rrMultiCustomerSearch(bodyshop, job, socket);
|
|
|
|
socket.emit("rr-select-customer", candidates);
|
|
CreateRRLogEvent(socket, "DEBUG", `{2.1} Emitted rr-select-customer`, {
|
|
count: candidates.length,
|
|
anyVinOwner: candidates.some((c) => c.vinOwner)
|
|
});
|
|
} catch (error) {
|
|
CreateRRLogEvent(socket, "ERROR", `Error during RR export (prepare)`, {
|
|
error: error.message,
|
|
stack: error.stack,
|
|
jobid: rid
|
|
});
|
|
try {
|
|
socket.emit("export-failed", { vendor: "rr", jobId: rid, error: error.message });
|
|
} catch {
|
|
//
|
|
}
|
|
}
|
|
});
|
|
|
|
// 2) Selection (or create) -> export
|
|
socket.on("rr-selected-customer", async ({ jobid, jobId, selectedCustomerId, custNo, create } = {}, ack) => {
|
|
const rid = resolveJobId(jobid || jobId, { jobid, jobId }, null);
|
|
try {
|
|
if (!rid) throw new Error("jobid required");
|
|
CreateRRLogEvent(socket, "DEBUG", `{3} rr-selected-customer`, {
|
|
jobid: rid,
|
|
custNo,
|
|
selectedCustomerId,
|
|
create: !!create
|
|
});
|
|
|
|
const ns = getTransactionType(rid);
|
|
let selectedCustNo =
|
|
(custNo && String(custNo)) ||
|
|
(selectedCustomerId && String(selectedCustomerId)) ||
|
|
(await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.SelectedCustomer));
|
|
|
|
const job = await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.JobData);
|
|
const txEnvelope = (await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.txEnvelope)) || {};
|
|
if (!job) throw new Error("Staged JobData not found (run rr-export-job first).");
|
|
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
if (create === true || !selectedCustNo) {
|
|
CreateRRLogEvent(socket, "DEBUG", `{3.1} Creating RR customer`);
|
|
const created = await createRRCustomer({ bodyshop, job, socket });
|
|
selectedCustNo = String(
|
|
created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey || ""
|
|
);
|
|
if (!selectedCustNo) throw new Error("RR create customer returned no custNo");
|
|
CreateRRLogEvent(socket, "DEBUG", `{3.2} Created customer`, { custNo: selectedCustNo });
|
|
}
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
String(selectedCustNo),
|
|
defaultRRTTL
|
|
);
|
|
CreateRRLogEvent(socket, "DEBUG", `{3.3} Cached selected customer`, { custNo: String(selectedCustNo) });
|
|
|
|
const cachedAdvisor = await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.AdvisorNo);
|
|
const advisorNo = readAdvisorNo({ txEnvelope }, cachedAdvisor);
|
|
if (!advisorNo) {
|
|
CreateRRLogEvent(socket, "ERROR", `Advisor is required (advisorNo)`);
|
|
socket.emit("export-failed", { vendor: "rr", jobId: rid, error: "Advisor is required (advisorNo)." });
|
|
return ack?.({ ok: false, error: "Advisor is required (advisorNo)." });
|
|
}
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.AdvisorNo,
|
|
String(advisorNo),
|
|
defaultRRTTL
|
|
);
|
|
|
|
CreateRRLogEvent(socket, "DEBUG", `{4} Performing RR export`);
|
|
const result = await exportJobToRR({
|
|
bodyshop,
|
|
job,
|
|
selectedCustomer: { custNo: String(selectedCustNo) },
|
|
advisorNo: String(advisorNo),
|
|
existing: txEnvelope?.existing,
|
|
socket
|
|
});
|
|
|
|
if (result?.success) {
|
|
CreateRRLogEvent(socket, "DEBUG", `{5} Export success`, { roStatus: result.roStatus });
|
|
socket.emit("export-success", { vendor: "rr", jobId: rid, roStatus: result.roStatus });
|
|
ack?.({ ok: true, result });
|
|
} else {
|
|
CreateRRLogEvent(socket, "ERROR", `Export failed`, { roStatus: result?.roStatus, error: result?.error });
|
|
socket.emit("export-failed", {
|
|
vendor: "rr",
|
|
jobId: rid,
|
|
roStatus: result?.roStatus,
|
|
error: result?.error || "RR export failed"
|
|
});
|
|
ack?.({ ok: false, error: result?.error || "RR export failed", result });
|
|
}
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.ExportResult,
|
|
result || {},
|
|
defaultRRTTL
|
|
);
|
|
socket.emit("rr-export-job:result", { jobId: rid, bodyshopId, result });
|
|
} catch (error) {
|
|
CreateRRLogEvent(socket, "ERROR", `Error during RR export (selected-customer)`, {
|
|
error: error.message,
|
|
stack: error.stack,
|
|
jobid: rid
|
|
});
|
|
try {
|
|
socket.emit("export-failed", { vendor: "rr", jobId: rid, error: error.message });
|
|
} catch {
|
|
//
|
|
}
|
|
ack?.({ ok: false, error: error.message });
|
|
}
|
|
});
|
|
|
|
// ---------- Allocations (parity) ----------
|
|
socket.on("rr-calculate-allocations", async (jobid, cb) => {
|
|
try {
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-calculate-allocations: begin", { jobid });
|
|
const allocations = await CdkCalculateAllocations(socket, jobid);
|
|
cb?.(allocations);
|
|
socket.emit("rr-calculate-allocations:result", allocations);
|
|
CreateRRLogEvent(socket, "DEBUG", "rr-calculate-allocations: success", { items: allocations?.length });
|
|
} catch (e) {
|
|
CreateRRLogEvent(socket, "ERROR", "rr-calculate-allocations: failed", { error: e.message, jobid });
|
|
cb?.({ ok: false, error: e.message });
|
|
}
|
|
});
|
|
}
|
|
|
|
module.exports = registerRREvents;
|