415 lines
16 KiB
JavaScript
415 lines
16 KiB
JavaScript
// server/rr/rr-register-socket-events.js
|
|
|
|
const RRLogger = require("../rr/rr-logger");
|
|
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");
|
|
|
|
// ---------------- utils ----------------
|
|
|
|
function resolveJobId(explicit, payload, job) {
|
|
return explicit || payload?.jobId || payload?.jobid || job?.id || job?.jobId || job?.jobid || null;
|
|
}
|
|
|
|
// ---- local helpers (avoid no-undef) ----
|
|
const digitsOnly = (s) => String(s || "").replace(/\D/g, "");
|
|
|
|
const makeVehicleSearchPayloadFromJob = (job) => {
|
|
const vin = job?.v_vin || job?.vehicle?.vin || job?.vehicle_vin || job?.vin;
|
|
if (vin) return { kind: "vin", vin: String(vin).trim() };
|
|
const plate = job?.plate_no || job?.vehicle?.plate || job?.vehicle_plate || job?.plate;
|
|
if (plate) return { kind: "license", license: String(plate).trim() };
|
|
return null;
|
|
};
|
|
|
|
const makeCustomerSearchPayloadFromJob = (job) => {
|
|
const phone = job?.ownr_ph1 || job?.customer?.mobile || job?.customer?.home_phone || job?.customer?.phone;
|
|
const d = digitsOnly(phone);
|
|
if (d.length >= 7) return { kind: "phone", phone: d };
|
|
|
|
const lastName = job?.ownr_ln || job?.customer?.last_name || job?.customer?.lastName;
|
|
const company = job?.ownr_co_nm || job?.customer?.company_name || job?.customer?.companyName;
|
|
const lnOrCompany = lastName || company;
|
|
if (lnOrCompany) return { kind: "name", name: { name: String(lnOrCompany).trim() } };
|
|
|
|
const vin = job?.v_vin || job?.vehicle?.vin || job?.vehicle_vin || job?.vin;
|
|
if (vin) return { kind: "vin", vin: String(vin).trim() };
|
|
|
|
return null;
|
|
};
|
|
|
|
const normalizeCustomerCandidates = (res) => {
|
|
// CombinedSearch may return array or { data: [...] }
|
|
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?.FName, ind?.LName].filter(Boolean).join(" ").trim();
|
|
const company = bus?.CompanyName;
|
|
const name = (personal || company || "").trim();
|
|
|
|
for (const custNo of custNos) {
|
|
out.push({ custNo, name: name || `Customer ${custNo}` });
|
|
}
|
|
}
|
|
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 {
|
|
/* ignore */
|
|
}
|
|
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;
|
|
}
|
|
|
|
// ---------------- register handlers ----------------
|
|
|
|
function registerRREvents({ socket, redisHelpers }) {
|
|
// RRLogger returns a log(level, message, ctx) function
|
|
const log = RRLogger(socket);
|
|
|
|
// Lookups (mirrors Fortellis shape/flow)
|
|
socket.on("rr-lookup-combined", async ({ jobid, params } = {}, cb) => {
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
const res = await rrCombinedSearch(bodyshop, params || {});
|
|
const data = res?.data ?? res;
|
|
|
|
cb?.({ jobid: resolveJobId(jobid, { jobid }, null), data });
|
|
|
|
// Push to FE to open the table; keep payload as the raw array (FE maps columns itself)
|
|
socket.emit("rr-select-customer", Array.isArray(data) ? data : data?.customers || []);
|
|
} catch (e) {
|
|
log("error", `RR combined lookup 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 });
|
|
const res = await rrGetAdvisors(bodyshop, args);
|
|
ack?.({ ok: true, result: res });
|
|
socket.emit("rr-get-advisors:result", res);
|
|
} catch (err) {
|
|
log("error", err?.message || "get advisors failed", { err });
|
|
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 });
|
|
const res = await rrGetParts(bodyshop, args);
|
|
ack?.({ ok: true, result: res });
|
|
socket.emit("rr-get-parts:result", res);
|
|
} catch (err) {
|
|
log("error", err?.message || "get parts failed", { err });
|
|
ack?.({ ok: false, error: err?.message || "get parts failed" });
|
|
}
|
|
});
|
|
|
|
// Persist customer selection (or flag create-new)
|
|
socket.on("rr-selected-customer", async (selected, ack) => {
|
|
try {
|
|
await getSessionOrSocket(redisHelpers, socket);
|
|
const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
|
|
|
|
// Signal create-new intent
|
|
if (!selected || selected?.create === true || selected?.__new === true) {
|
|
await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrCreateCustomer: true });
|
|
log("info", "rr-selected-customer:new-customer-intent");
|
|
socket.emit("rr-customer-create-required");
|
|
return ack?.({ ok: true, action: "create" });
|
|
}
|
|
|
|
await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedCustomer: selected });
|
|
log("info", "rr-selected-customer", { selected });
|
|
ack?.({ ok: true });
|
|
} catch (err) {
|
|
log("error", err?.message || "select customer failed", { err });
|
|
ack?.({ ok: false, error: err?.message || "select customer failed" });
|
|
}
|
|
});
|
|
|
|
// Optional explicit create-customer from UI form
|
|
socket.on("rr-create-customer", async ({ jobId, fields } = {}, ack) => {
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
if (!jobId) throw new Error("jobId required");
|
|
const job = await QueryJobData({ redisHelpers }, jobId);
|
|
|
|
const { custNo } = await createRRCustomer({ bodyshop, job, overrides: fields || {}, socket });
|
|
|
|
const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
|
|
await redisHelpers.setSessionTransactionData(socket.id, {
|
|
...tx,
|
|
rrSelectedCustomer: { custNo },
|
|
rrCreateCustomer: false
|
|
});
|
|
|
|
log("info", "rr-create-customer:success", { custNo });
|
|
socket.emit("rr-customer-created", { custNo });
|
|
ack?.({ ok: true, custNo });
|
|
} catch (err) {
|
|
log("error", err?.message || "create customer failed", { err });
|
|
ack?.({ ok: false, error: err?.message || "create customer failed" });
|
|
}
|
|
});
|
|
|
|
// Vehicle selection helpers
|
|
socket.on("rr-selected-vehicle", async (selected, ack) => {
|
|
try {
|
|
await getSessionOrSocket(redisHelpers, socket);
|
|
if (!selected?.vin) throw new Error("selected vehicle must include vin");
|
|
const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
|
|
await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedVehicle: selected });
|
|
log("info", "rr-selected-vehicle", { vin: selected.vin });
|
|
ack?.({ ok: true });
|
|
} catch (err) {
|
|
log("error", err?.message || "select vehicle failed", { err });
|
|
ack?.({ ok: false, error: err?.message || "select vehicle failed" });
|
|
}
|
|
});
|
|
|
|
socket.on("rr-create-vehicle", async (vehicle, ack) => {
|
|
try {
|
|
await getSessionOrSocket(redisHelpers, socket);
|
|
if (!vehicle?.vin) throw new Error("vehicle.vin required");
|
|
const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
|
|
await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedVehicle: vehicle });
|
|
log("info", "rr-create-vehicle", { vin: vehicle.vin });
|
|
ack?.({ ok: true });
|
|
} catch (err) {
|
|
log("error", err?.message || "create vehicle failed", { err });
|
|
ack?.({ ok: false, error: err?.message || "create vehicle failed" });
|
|
}
|
|
});
|
|
|
|
// Export flow
|
|
socket.on("rr-export-job", async (payload = {}) => {
|
|
try {
|
|
// -------- 1) Resolve job --------
|
|
let job = payload.job || payload.txEnvelope?.job;
|
|
const jobId = payload.jobId || payload.jobid || payload.txEnvelope?.jobId || job?.id;
|
|
|
|
if (!job) {
|
|
if (!jobId) throw new Error("RR export: job or jobId required");
|
|
job = await QueryJobData({ redisHelpers }, jobId);
|
|
}
|
|
|
|
// -------- 2) Resolve bodyshop (+ full row via GraphQL) --------
|
|
let bodyshopId = payload.bodyshopId || payload.bodyshopid || payload.bodyshopUUID || job?.bodyshop?.id;
|
|
|
|
if (!bodyshopId) {
|
|
const sess = await getSessionOrSocket(redisHelpers, socket);
|
|
bodyshopId = sess.bodyshopId;
|
|
}
|
|
if (!bodyshopId) throw new Error("RR export: bodyshopId required");
|
|
|
|
// Authoritative bodyshop row for RR routing (env fallback handled downstream)
|
|
let bodyshop =
|
|
job?.bodyshop && (job.bodyshop.rr_dealerid || job.bodyshop.rr_configuration)
|
|
? job.bodyshop
|
|
: await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
// Optional FE routing override (kept minimal/safe)
|
|
const feRouting = payload.rrRouting;
|
|
if (feRouting) {
|
|
const cfg = bodyshop.rr_configuration || {};
|
|
bodyshop = {
|
|
...bodyshop,
|
|
rr_dealerid: feRouting.dealerNumber ?? bodyshop.rr_dealerid,
|
|
rr_configuration: {
|
|
...cfg,
|
|
storeNumber: feRouting.storeNumber ?? cfg.storeNumber,
|
|
branchNumber: feRouting.areaNumber ?? cfg.branchNumber,
|
|
areaNumber: feRouting.areaNumber ?? cfg.areaNumber
|
|
}
|
|
};
|
|
}
|
|
|
|
// -------- 3) Resolve selected customer (payload → tx) --------
|
|
const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
|
|
let selectedCustomer = null;
|
|
|
|
// from payload
|
|
if (payload.selectedCustomer) {
|
|
if (typeof payload.selectedCustomer === "object" && payload.selectedCustomer.custNo) {
|
|
selectedCustomer = { custNo: String(payload.selectedCustomer.custNo) };
|
|
} else if (typeof payload.selectedCustomer === "string") {
|
|
selectedCustomer = { custNo: String(payload.selectedCustomer) };
|
|
}
|
|
}
|
|
|
|
// from tx
|
|
if (!selectedCustomer && tx.rrSelectedCustomer) {
|
|
if (typeof tx.rrSelectedCustomer === "object" && tx.rrSelectedCustomer.custNo) {
|
|
selectedCustomer = { custNo: String(tx.rrSelectedCustomer.custNo) };
|
|
} else {
|
|
selectedCustomer = { custNo: String(tx.rrSelectedCustomer) };
|
|
}
|
|
}
|
|
|
|
const forceCreate = payload.forceCreate === true || tx.rrCreateCustomer === true;
|
|
|
|
// -------- 4) If no selection & not "forceCreate", try auto-search then ask UI to pick --------
|
|
if (!selectedCustomer && !forceCreate) {
|
|
const customerQuery = makeCustomerSearchPayloadFromJob(job);
|
|
const vehicleQuery = makeVehicleSearchPayloadFromJob(job);
|
|
const query = customerQuery || vehicleQuery;
|
|
|
|
if (query) {
|
|
log("info", "rr-export-job:customer-preselect-search", { query, jobId });
|
|
const searchRes = await rrCombinedSearch(bodyshop, query);
|
|
const candidates = normalizeCustomerCandidates(searchRes);
|
|
|
|
if (candidates.length === 1) {
|
|
// auto-pick single hit
|
|
selectedCustomer = { custNo: String(candidates[0].custNo) };
|
|
await redisHelpers.setSessionTransactionData(socket.id, {
|
|
...tx,
|
|
rrSelectedCustomer: selectedCustomer.custNo,
|
|
rrCreateCustomer: false
|
|
});
|
|
log("info", "rr-export-job:auto-selected-customer", { jobId, custNo: selectedCustomer.custNo });
|
|
} else if (candidates.length > 1) {
|
|
// emit picker data and stop; UI will call rr-selected-customer next
|
|
const table = candidates.map((c) => ({
|
|
CustomerId: c.custNo,
|
|
customerId: c.custNo,
|
|
CustomerName: { FirstName: c.name || String(c.custNo), LastName: "" }
|
|
}));
|
|
socket.emit("rr-select-customer", table);
|
|
socket.emit("rr-log-event", { level: "info", message: "RR: customer selection required", ts: Date.now() });
|
|
return; // wait for user selection
|
|
}
|
|
}
|
|
|
|
// no query or no matches → ask UI to create
|
|
if (!selectedCustomer) {
|
|
await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrCreateCustomer: true });
|
|
socket.emit("rr-customer-create-required");
|
|
socket.emit("rr-log-event", { level: "info", message: "RR: create customer required", ts: Date.now() });
|
|
return;
|
|
}
|
|
}
|
|
|
|
// -------- 5) If still not selected & creation is allowed, create now --------
|
|
if (!selectedCustomer && forceCreate) {
|
|
const { createRRCustomer } = require("../rr/rr-customers");
|
|
const created = await createRRCustomer({ bodyshop, job, socket });
|
|
// fallback when API returns only DMSRecKey
|
|
const custNo = created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey;
|
|
|
|
if (!custNo) throw new Error("RR create customer returned no custNo");
|
|
|
|
selectedCustomer = { custNo: String(custNo) };
|
|
await redisHelpers.setSessionTransactionData(socket.id, {
|
|
...tx,
|
|
rrSelectedCustomer: selectedCustomer.custNo,
|
|
rrCreateCustomer: false
|
|
});
|
|
log("info", "rr-export-job:customer-created", { jobId, custNo: selectedCustomer.custNo });
|
|
}
|
|
|
|
if (!selectedCustomer?.custNo) throw new Error("RR export: selected customer missing custNo");
|
|
|
|
// -------- 6) Perform export --------
|
|
const advisorNo = payload.advisorNo || payload.advNo || tx.rrAdvisorNo;
|
|
const options = payload.options || payload.txEnvelope?.options || {};
|
|
|
|
const result = await exportJobToRR({
|
|
bodyshop,
|
|
job,
|
|
selectedCustomer,
|
|
advisorNo,
|
|
existing: payload.existing,
|
|
logger: log,
|
|
...options
|
|
});
|
|
|
|
if (result?.success) {
|
|
socket.emit("export-success", { vendor: "rr", jobId, roStatus: result.roStatus });
|
|
} else {
|
|
socket.emit("export-failed", {
|
|
vendor: "rr",
|
|
jobId,
|
|
roStatus: result?.roStatus,
|
|
error: result?.error || "RR export failed"
|
|
});
|
|
}
|
|
|
|
socket.emit("rr-export-job:result", { jobId, bodyshopId, result });
|
|
} catch (error) {
|
|
const jobId = payload.jobId || payload.jobid || payload.txEnvelope?.jobId || payload?.job?.id;
|
|
log("error", `Error during RR export: ${error.message}`, { jobId, stack: error.stack });
|
|
try {
|
|
socket.emit("export-failed", { vendor: "rr", jobId, error: error.message });
|
|
} catch {
|
|
//
|
|
}
|
|
}
|
|
});
|
|
|
|
// Allocations (RR reuses CDK calculator)
|
|
socket.on("rr-calculate-allocations", async (jobid, cb) => {
|
|
try {
|
|
const allocations = await CdkCalculateAllocations(socket, jobid);
|
|
cb?.(allocations);
|
|
socket.emit("rr-calculate-allocations:result", allocations);
|
|
} catch (e) {
|
|
log("error", `RR allocations error: ${e.message}`, { jobid });
|
|
cb?.({ ok: false, error: e.message });
|
|
}
|
|
});
|
|
}
|
|
|
|
module.exports = registerRREvents;
|