bodyshop/server/web-sockets/rr-register-socket-events.js

// 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;