admin/bodyshop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feature/IO-3357-Reynolds-and-Reynolds-DMS-API-Integration - Checkpoint

Browse Source
This commit is contained in:
Dave
2025-11-04 11:19:20 -05:00
parent 65e26ed5c9
commit 3d24d44274
23 changed files with 812 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
server/web-sockets/redisSocketEvents.js
View File

@@ -1,16 +1,12 @@
const { admin } = require("../firebase/firebase-handler");
const FortellisLogger = require("../fortellis/fortellis-logger");
const RRLogger = require("../rr/rr-logger");
const { FortellisJobExport, FortellisSelectedCustomer } = require("../fortellis/fortellis");
const CdkCalculateAllocations = require("../cdk/cdk-calculate-allocations").default;
const registerRREvents = require("./rr-register-socket-events");
const lookupApi = require("../rr/rr-lookup");
const { SelectedCustomer } = require("../rr/rr-selected-customer");
const { QueryJobData } = require("../rr/rr-job-helpers");
const redisSocketEvents = ({
io,
redisHelpers: {
const redisSocketEvents = ({ io, redisHelpers, ioHelpers, logger }) => {
// Destructure helpers locally, but keep full objects available for downstream modules
const {
setSessionData,
getSessionData,
addUserSocketMapping,
@@ -20,10 +16,10 @@ const redisSocketEvents = ({
setSessionTransactionData,
getSessionTransactionData,
clearSessionTransactionData
},
ioHelpers: { getBodyshopRoom, getBodyshopConversationRoom },
logger
}) => {
} = redisHelpers;
const { getBodyshopRoom, getBodyshopConversationRoom } = ioHelpers;
// Logging helper functions
const createLogEvent = (socket, level, message) => {
logger.log("ioredis-log-event", level, socket?.user?.email, null, { wsmessage: message });
@@ -53,6 +49,15 @@ const redisSocketEvents = ({
socket.handshake.auth.token = token;
socket.handshake.auth.bodyshopId = bodyshopId;
}
// NEW: seed a base session for this socket so downstream handlers can read it
await setSessionData(socket.id, {
bodyshopId,
email: user.email,
uid: user.user_id || user.uid,
seededAt: Date.now()
});
await addUserSocketMapping(user.email, socket.id, bodyshopId);
next();
} catch (error) {
@@ -91,6 +96,15 @@ const redisSocketEvents = ({
socket.handshake.auth.token = token;
socket.handshake.auth.bodyshopId = bodyshopId;
}
// NEW: refresh (or create) the base session with the latest info
await setSessionData(socket.id, {
bodyshopId,
email: user.email,
uid: user.user_id || user.uid,
refreshedAt: Date.now()
});
await refreshUserSocketTTL(user.email, bodyshopId);
socket.emit("token-updated", { success: true });
} catch (error) {
@@ -147,6 +161,10 @@ const redisSocketEvents = ({
if (socket.user?.email) {
await removeUserSocketMapping(socket.user.email, socket.id);
}
// Optional: clear transactional session
try {
await clearSessionTransactionData(socket.id);
} catch {}
// Leave all rooms except the default room (socket.id)
const rooms = Array.from(socket.rooms).filter((room) => room !== socket.id);
for (const room of rooms) {
@@ -251,7 +269,7 @@ const redisSocketEvents = ({
});
};
//Fortellis/CDK Handlers
// Fortellis/CDK Handlers
const registerFortellisEvents = (socket) => {
socket.on("fortellis-export-job", async ({ jobid, txEnvelope }) => {
try {
@@ -280,6 +298,7 @@ const redisSocketEvents = ({
});
}
});
socket.on("fortellis-selected-customer", async ({ jobid, selectedCustomerId }) => {
try {
await FortellisSelectedCustomer({
@@ -307,6 +326,7 @@ const redisSocketEvents = ({
});
}
});
socket.on("fortellis-calculate-allocations", async (jobid, callback) => {
try {
const allocations = await CdkCalculateAllocations(socket, jobid);
@@ -342,94 +362,6 @@ const redisSocketEvents = ({
});
};
// Reynolds & Reynolds socket events (uses new client-backed ops)
function registerRREvents(socket) {
const logger = require("../utils/logger");
const log = RRLogger(socket);
const {
redisHelpers // { setSessionData, getSessionData, ... setSessionTransactionData, getSessionTransactionData }
} = require("../utils/ioHelpers").getHelpers?.() || { redisHelpers: {} };
const resolveJobId = (maybeId, packet, fallback) => maybeId || packet?.jobid || fallback;
// Lookups
socket.on("rr-get-advisors", async (params = {}, cb) => {
try {
const bodyshopId = params.bodyshopId || socket?.user?.bodyshopid;
const res = await lookupApi.getAdvisors({ bodyshopId, ...(params || {}) });
cb?.({ data: res?.data ?? res });
} catch (e) {
log("error", `RR get advisors error: ${e.message}`);
cb?.({ error: e.message });
}
});
socket.on("rr-get-parts", async (params = {}, cb) => {
try {
const bodyshopId = params.bodyshopId || socket?.user?.bodyshopid;
const res = await lookupApi.getParts({ bodyshopId, ...(params || {}) });
cb?.({ data: res?.data ?? res });
} catch (e) {
log("error", `RR get parts error: ${e.message}`);
cb?.({ error: e.message });
}
});
/**
* NEW: QueryJobData — return the canonical job payload used for DMS exports
* payload: { jobid }
*/
socket.on("rr-query-job-data", async ({ jobid } = {}, cb) => {
try {
const resolvedJobId = resolveJobId(jobid, { jobid }, null);
const job = await QueryJobData({ socket, jobid: resolvedJobId });
cb?.({ jobid: resolvedJobId, job });
} catch (e) {
log("error", `RR query job data error: ${e.message}`, { jobid });
cb?.({ jobid, error: e.message });
}
});
/**
* NEW: Selected Customer — cache the chosen DMS customer (or upsert from job if not provided)
* payload: { jobid, selectedCustomerId?, bodyshopId? }
*/
socket.on("rr-selected-customer", async ({ jobid, selectedCustomerId, bodyshopId } = {}, cb) => {
try {
const resolvedJobId = resolveJobId(jobid, { jobid }, null);
const result = await SelectedCustomer({
socket,
jobid: resolvedJobId,
bodyshopId,
selectedCustomerId,
redisHelpers
});
cb?.({ jobid: resolvedJobId, selectedCustomerId: result.selectedCustomerId });
} catch (e) {
log("error", `RR selected customer error: ${e.message}`, { jobid });
cb?.({ jobid, error: e.message });
}
});
// Calculate allocations (unchanged)
socket.on("rr-calculate-allocations", async (jobid, callback) => {
try {
const resolvedJobId = resolveJobId(jobid, { jobid }, null);
const allocations = await CdkCalculateAllocations(socket, resolvedJobId);
callback?.({ jobid: resolvedJobId, allocations });
} catch (error) {
log("error", `Error during RR calculate allocations: ${error.message}`, { jobid, stack: error.stack });
logger.log("rr-calc-allocations-error", "error", null, null, {
jobid,
message: error.message,
stack: error.stack
});
callback?.({ jobid, error: error.message });
}
});
}
module.exports = { registerRREvents };
// Call Handlers
registerRoomAndBroadcastEvents(socket);
registerUpdateEvents(socket);
@@ -438,7 +370,14 @@ const redisSocketEvents = ({
registerSyncEvents(socket);
registerTaskEvents(socket);
registerFortellisEvents(socket);
registerRREvents(socket);
// Reynolds & Reynolds socket handlers
registerRREvents({
socket,
redisHelpers,
ioHelpers,
logger
});
};
// Associate Middleware and Handlers

305
server/web-sockets/rr-register-socket-events.js Normal file
View File

@@ -0,0 +1,305 @@
// 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;
}
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
// Export flow
socket.on("rr-export-job", async (payload = {}) => {
try {
// Extract job / ids
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");
// Fetch full job when only jobId is provided
job = await QueryJobData({ redisHelpers }, jobId);
}
// Resolve bodyshop id
let bodyshopId = payload.bodyshopId || payload.bodyshopid || payload.bodyshopUUID || job?.bodyshop?.id;
if (!bodyshopId) {
const { bodyshopId: sid } = await getSessionOrSocket(redisHelpers, socket);
bodyshopId = sid;
}
if (!bodyshopId) throw new Error("RR export: bodyshopId required");
// Load authoritative bodyshop row (so rr-config can read routing)
let bodyshop = job?.bodyshop || (await getBodyshopForSocket({ bodyshopId, socket })) || { id: bodyshopId };
// Optional FE routing override (safe: routing only)
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
}
};
}
// Selected customer resolution (tx → payload → create)
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: payload.selectedCustomer.custNo };
} else if (typeof payload.selectedCustomer === "string") {
selectedCustomer = { custNo: payload.selectedCustomer };
}
}
// from tx if still not set
if (!selectedCustomer && tx.rrSelectedCustomer) {
if (typeof tx.rrSelectedCustomer === "object" && tx.rrSelectedCustomer.custNo) {
selectedCustomer = { custNo: tx.rrSelectedCustomer.custNo };
} else {
selectedCustomer = { custNo: tx.rrSelectedCustomer };
}
}
// create on demand (flagged or missing)
if (!selectedCustomer || tx.rrCreateCustomer === true) {
const created = await createRRCustomer({ bodyshop, job, socket });
selectedCustomer = { custNo: created.custNo };
await redisHelpers.setSessionTransactionData(socket.id, {
...tx,
rrSelectedCustomer: created.custNo,
rrCreateCustomer: false
});
log("info", "rr-export-job:customer-created", { jobId, custNo: created.custNo });
}
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 {
// ignore
}
}
});
// 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;