562 lines
22 KiB
JavaScript
562 lines
22 KiB
JavaScript
// File: server/rr/rr-register-socket-events.js
|
|
// PATCH: add helper + modify rr-export-job customer preselect logic
|
|
|
|
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");
|
|
|
|
// Use the same namespacing/TTL approach as Fortellis
|
|
const { getTransactionType, defaultFortellisTTL } = require("../fortellis/fortellis-helpers");
|
|
|
|
// ---------------- cache keys (RR) ----------------
|
|
const RRCacheEnums = {
|
|
txEnvelope: "RR.txEnvelope",
|
|
JobData: "RR.JobData",
|
|
SelectedCustomer: "RR.SelectedCustomer",
|
|
AdvisorNo: "RR.AdvisorNo",
|
|
// Vehicle keys reserved for future multi-vehicle UX parity
|
|
VINCandidates: "RR.VINCandidates",
|
|
SelectedVin: "RR.SelectedVin",
|
|
ExportResult: "RR.ExportResult"
|
|
};
|
|
const defaultRRTTL = defaultFortellisTTL || 60 * 60; // fallback 1h
|
|
|
|
// ---------------- 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 || 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;
|
|
};
|
|
|
|
// Normalize to the RR table shape expected by FE (custNo + name)
|
|
const normalizeCustomerCandidates = (res) => {
|
|
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: String(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;
|
|
}
|
|
|
|
function readAdvisorNo(payload, cached) {
|
|
const v =
|
|
(payload?.txEnvelope?.advisorNo != null && String(payload.txEnvelope.advisorNo)) ||
|
|
(payload?.advisorNo != null && String(payload.advisorNo)) ||
|
|
(payload?.advNo != null && String(payload.advNo)) ||
|
|
(cached != null && String(cached)) ||
|
|
null;
|
|
return v && v.trim() !== "" ? v : null;
|
|
}
|
|
|
|
// ---------------- register handlers ----------------
|
|
function registerRREvents({ socket, redisHelpers }) {
|
|
const log = RRLogger(socket);
|
|
|
|
// --- NEW helper: run name + vin searches and merge ---
|
|
async function rrMultiCustomerSearch(bodyshop, job) {
|
|
const queries = [];
|
|
|
|
// Extract fields
|
|
const fname = (job?.ownr_fn || job?.customer?.first_name || job?.customer?.firstName || "").trim();
|
|
const lname = (job?.ownr_ln || job?.customer?.last_name || job?.customer?.lastName || "").trim();
|
|
const vin = (job?.v_vin || job?.vehicle?.vin || job?.vin || "").trim();
|
|
|
|
// Build combined query if possible
|
|
if (vin && (fname || lname)) {
|
|
const nameObj = {};
|
|
if (fname) nameObj.fname = fname;
|
|
if (lname) nameObj.lname = lname;
|
|
queries.push({
|
|
kind: "name",
|
|
name: nameObj,
|
|
vin: vin,
|
|
maxResults: 50
|
|
});
|
|
} else if (vin) {
|
|
queries.push({ kind: "vin", vin: vin, maxResults: 50 });
|
|
} else if (fname || lname) {
|
|
// Standalone name: prefer FullName if both, else LName if only lname (though spec prefers combos)
|
|
// Note: Standalone Last Name not in spec; use with caution or add MMY if available
|
|
const nameObj = {};
|
|
if (fname) nameObj.fname = fname;
|
|
if (lname) nameObj.lname = lname;
|
|
queries.push({
|
|
kind: "name",
|
|
name: nameObj,
|
|
maxResults: 50
|
|
});
|
|
}
|
|
|
|
if (!queries.length) return [];
|
|
|
|
// Execute searches serially (could be Promise.all; keep serial for vendor rate safety)
|
|
const all = [];
|
|
for (const q of queries) {
|
|
try {
|
|
const res = await rrCombinedSearch(bodyshop, q);
|
|
const norm = normalizeCustomerCandidates(res);
|
|
all.push(...norm);
|
|
} catch (e) {
|
|
log("warn", "multi-search subquery failed", { kind: q.kind, error: e.message });
|
|
}
|
|
}
|
|
|
|
// De-dupe by custNo
|
|
const seen = new Set();
|
|
const merged = [];
|
|
for (const c of all) {
|
|
const k = c && c.custNo && String(c.custNo).trim();
|
|
if (!k || seen.has(k)) continue;
|
|
seen.add(k);
|
|
merged.push({ custNo: String(c.custNo), name: c.name });
|
|
}
|
|
return merged;
|
|
}
|
|
|
|
// --------- Lookups (customer search → open table) ---------
|
|
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 normalized = normalizeCustomerCandidates(res);
|
|
|
|
const rid = resolveJobId(jobid, { jobid }, null);
|
|
cb?.({ jobid: rid, data: normalized });
|
|
|
|
// FE expects { custNo, name }
|
|
socket.emit("rr-select-customer", normalized);
|
|
} 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 / create-intent (table-first UX) ---------
|
|
socket.on("rr-selected-customer", async ({ jobId, custNo, create } = {}, ack) => {
|
|
const ns = getTransactionType(jobId || "unknown");
|
|
try {
|
|
const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
|
|
const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
|
|
if (!jobId) throw new Error("jobId required");
|
|
|
|
// If caller passed a selection, just persist it.
|
|
if (custNo && create !== true) {
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
String(custNo),
|
|
defaultRRTTL
|
|
);
|
|
log("info", "rr-selected-customer", { jobId, custNo: String(custNo) });
|
|
return ack?.({ ok: true });
|
|
}
|
|
|
|
// No custNo (or create: true) => create immediately from JobData (Fortellis parity)
|
|
const job = await QueryJobData({ redisHelpers }, jobId);
|
|
const created = await createRRCustomer({ bodyshop, job, socket });
|
|
const newCustNo = String(
|
|
created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey || ""
|
|
);
|
|
if (!newCustNo) throw new Error("RR create customer returned no custNo");
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
newCustNo,
|
|
defaultRRTTL
|
|
);
|
|
|
|
log("info", "rr-create-customer:success", { jobId, custNo: newCustNo });
|
|
return ack?.({ ok: true, custNo: newCustNo });
|
|
} catch (err) {
|
|
log("error", err?.message || "select/create customer failed", { err, jobId });
|
|
return ack?.({ ok: false, error: err?.message || "select/create customer failed" });
|
|
}
|
|
});
|
|
|
|
// --------- Optional explicit create-customer (form) ---------
|
|
socket.on("rr-create-customer", async ({ jobId, fields } = {}, ack) => {
|
|
const ns = getTransactionType(jobId || "unknown");
|
|
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 created = await createRRCustomer({ bodyshop, job, overrides: fields || {}, socket });
|
|
const custNo = String(created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey || "");
|
|
if (!custNo) throw new Error("RR create customer returned no custNo");
|
|
|
|
await redisHelpers.setSessionTransactionData(socket.id, ns, RRCacheEnums.SelectedCustomer, custNo, defaultRRTTL);
|
|
await redisHelpers.setSessionTransactionData(socket.id, ns, "RR.CreateCustomerIntent", false, defaultRRTTL);
|
|
|
|
log("info", "rr-create-customer:success", { jobId, custNo });
|
|
socket.emit("rr-customer-created", { custNo });
|
|
ack?.({ ok: true, custNo });
|
|
} catch (err) {
|
|
log("error", err?.message || "create customer failed", { err, jobId });
|
|
ack?.({ ok: false, error: err?.message || "create customer failed" });
|
|
}
|
|
});
|
|
|
|
// --------- Vehicle selection hooks (reserved for future parity) ---------
|
|
socket.on("rr-selected-vehicle", async ({ jobId, vin } = {}, ack) => {
|
|
const ns = getTransactionType(jobId || "unknown");
|
|
try {
|
|
await getSessionOrSocket(redisHelpers, socket);
|
|
if (!vin) throw new Error("vin required");
|
|
await redisHelpers.setSessionTransactionData(socket.id, ns, RRCacheEnums.SelectedVin, String(vin), defaultRRTTL);
|
|
log("info", "rr-selected-vehicle", { jobId, vin: String(vin) });
|
|
ack?.({ ok: true });
|
|
} catch (err) {
|
|
log("error", err?.message || "select vehicle failed", { err, jobId });
|
|
ack?.({ ok: false, error: err?.message || "select vehicle failed" });
|
|
}
|
|
});
|
|
|
|
socket.on("rr-create-vehicle", async ({ jobId, vehicle } = {}, ack) => {
|
|
const ns = getTransactionType(jobId || "unknown");
|
|
try {
|
|
await getSessionOrSocket(redisHelpers, socket);
|
|
if (!vehicle?.vin) throw new Error("vehicle.vin required");
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedVin,
|
|
String(vehicle.vin),
|
|
defaultRRTTL
|
|
);
|
|
log("info", "rr-create-vehicle", { jobId, vin: String(vehicle.vin) });
|
|
ack?.({ ok: true });
|
|
} catch (err) {
|
|
log("error", err?.message || "create vehicle failed", { err, jobId });
|
|
ack?.({ ok: false, error: err?.message || "create vehicle failed" });
|
|
}
|
|
});
|
|
|
|
// --------- Main export (Fortellis-style staging) ---------
|
|
socket.on("rr-export-job", async (payload = {}) => {
|
|
const _log = RRLogger(socket, { ns: "rr" });
|
|
try {
|
|
// (existing preamble unchanged)
|
|
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);
|
|
}
|
|
const ns = getTransactionType(job.id);
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.txEnvelope,
|
|
payload.txEnvelope || {},
|
|
defaultRRTTL
|
|
);
|
|
await redisHelpers.setSessionTransactionData(socket.id, ns, RRCacheEnums.JobData, job, defaultRRTTL);
|
|
|
|
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");
|
|
|
|
const bodyshop =
|
|
job?.bodyshop && (job.bodyshop.rr_dealerid || job.bodyshop.rr_configuration)
|
|
? job.bodyshop
|
|
: await getBodyshopForSocket({ bodyshopId, socket });
|
|
|
|
const cachedAdvisor = await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.AdvisorNo);
|
|
const advisorNo = readAdvisorNo(payload, cachedAdvisor);
|
|
if (!advisorNo) {
|
|
socket.emit("export-failed", { vendor: "rr", jobId, error: "Advisor is required (advisorNo)." });
|
|
return;
|
|
}
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.AdvisorNo,
|
|
String(advisorNo),
|
|
defaultRRTTL
|
|
);
|
|
|
|
let selectedCust = null;
|
|
if (payload.selectedCustomer) {
|
|
if (typeof payload.selectedCustomer === "object" && payload.selectedCustomer.custNo) {
|
|
selectedCust = { custNo: String(payload.selectedCustomer.custNo) };
|
|
} else if (typeof payload.selectedCustomer === "string" || typeof payload.selectedCustomer === "number") {
|
|
selectedCust = { custNo: String(payload.selectedCustomer) };
|
|
}
|
|
if (selectedCust?.custNo) {
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
selectedCust.custNo,
|
|
defaultRRTTL
|
|
);
|
|
}
|
|
}
|
|
if (!selectedCust) {
|
|
const cached = await redisHelpers.getSessionTransactionData(socket.id, ns, RRCacheEnums.SelectedCustomer);
|
|
if (cached) selectedCust = { custNo: String(cached) };
|
|
}
|
|
|
|
const forceCreate = payload.forceCreate === true;
|
|
const autoCreateOnNoMatch = payload.autoCreateOnNoMatch !== false;
|
|
|
|
// --- MODIFIED: multi-search (name + vin) when beginning selection ---
|
|
if (!selectedCust && !forceCreate) {
|
|
const mergedCandidates = await rrMultiCustomerSearch(bodyshop, job);
|
|
|
|
if (mergedCandidates.length === 1) {
|
|
selectedCust = { custNo: String(mergedCandidates[0].custNo) };
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
selectedCust.custNo,
|
|
defaultRRTTL
|
|
);
|
|
_log("info", "rr-export-job:auto-selected-customer(multi)", { jobId, custNo: selectedCust.custNo });
|
|
} else if (mergedCandidates.length > 1) {
|
|
socket.emit("rr-select-customer", mergedCandidates);
|
|
socket.emit("rr-log-event", {
|
|
level: "info",
|
|
message: "RR: customer selection required (multi-search)",
|
|
ts: Date.now()
|
|
});
|
|
return; // wait for user selection
|
|
} else {
|
|
// Fallback to original single-query logic (phone etc.) only if no multi results
|
|
// (retain legacy behavior)
|
|
const fallbackQuery = makeCustomerSearchPayloadFromJob(job) || makeVehicleSearchPayloadFromJob(job) || null;
|
|
|
|
if (fallbackQuery) {
|
|
_log("info", "rr-export-job:fallback-single-query", { fallbackQuery, jobId });
|
|
try {
|
|
const searchRes = await rrCombinedSearch(bodyshop, fallbackQuery);
|
|
const candidates = normalizeCustomerCandidates(searchRes);
|
|
if (candidates.length === 1) {
|
|
selectedCust = { custNo: String(candidates[0].custNo) };
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
selectedCust.custNo,
|
|
defaultRRTTL
|
|
);
|
|
_log("info", "rr-export-job:auto-selected-customer(fallback)", {
|
|
jobId,
|
|
custNo: selectedCust.custNo
|
|
});
|
|
} else if (candidates.length > 1) {
|
|
socket.emit("rr-select-customer", candidates);
|
|
socket.emit("rr-log-event", {
|
|
level: "info",
|
|
message: "RR: customer selection required",
|
|
ts: Date.now()
|
|
});
|
|
return;
|
|
}
|
|
} catch (e) {
|
|
_log("warn", "rr-export-job:fallback-query failed", { error: e.message });
|
|
}
|
|
}
|
|
|
|
if (!selectedCust) {
|
|
if (autoCreateOnNoMatch) {
|
|
const created = await createRRCustomer({ bodyshop, job, socket });
|
|
const custNo = created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey;
|
|
if (!custNo) throw new Error("RR create customer returned no custNo");
|
|
selectedCust = { custNo: String(custNo) };
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.SelectedCustomer,
|
|
selectedCust.custNo,
|
|
defaultRRTTL
|
|
);
|
|
_log("info", "rr-export-job:auto-created-customer(multi-zero)", {
|
|
jobId,
|
|
custNo: selectedCust.custNo
|
|
});
|
|
} else {
|
|
socket.emit("rr-customer-create-required");
|
|
socket.emit("rr-log-event", {
|
|
level: "info",
|
|
message: "RR: create customer required",
|
|
ts: Date.now()
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!selectedCust?.custNo) throw new Error("RR export: selected customer missing custNo");
|
|
|
|
// (rest of existing export logic unchanged)
|
|
const result = await exportJobToRR({
|
|
bodyshop,
|
|
job,
|
|
selectedCustomer: selectedCust,
|
|
advisorNo: String(advisorNo),
|
|
existing: payload.existing,
|
|
socket
|
|
});
|
|
|
|
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"
|
|
});
|
|
}
|
|
|
|
await redisHelpers.setSessionTransactionData(
|
|
socket.id,
|
|
ns,
|
|
RRCacheEnums.ExportResult,
|
|
result || {},
|
|
defaultRRTTL
|
|
);
|
|
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 (reuse 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;
|