bodyshop/server/rr/rrRoutes.js

/**
 * @file rrRoutes.js
 * @description Express routes for Reynolds & Reynolds (Rome) integration.
 * Endpoints:
 *  - POST /rr/customer/insert
 *  - POST /rr/customer/update
 *  - POST /rr/repair-order/create
 *  - POST /rr/repair-order/update
 *  - POST /rr/lookup/advisors
 *  - POST /rr/lookup/parts
 *  - POST /rr/lookup/combined-search
 *  - POST /rr/export/job
 *  - GET  /rr/actions
 *  - GET  /rr/templates/verify
 */

const express = require("express");
const router = express.Router();

const RRLogger = require("./rr-logger");
const { RrApiError } = require("./rr-error");

// Domain modules
const customerApi = require("./rr-customer"); // insertCustomer, updateCustomer
const roApi = require("./rr-repair-orders"); // createRepairOrder, updateRepairOrder
const lookupApi = require("./rr-lookup"); // getAdvisors, getParts, combinedSearch
const { exportJobToRome } = require("./rr-job-export"); // orchestrator

// Diagnostics
const { listActions, verifyTemplatesExist } = require("./rr-wsdl");

// DB-driven RR config (no env fallback for dealer/store/branch here)
const { getRRConfigForBodyshop } = require("./rr-config");

// -------------------- Helpers --------------------

function ok(res, payload = {}) {
  return res.json({ success: true, ...payload });
}

function fail(res, error, status = 400) {
  const message = error?.message || String(error);
  return res.status(status).json({ success: false, error: message, code: error?.code });
}

function socketOf(req) {
  // If you stash a socket/logging context on the app, grab it; otherwise null
  return (req.app && req.app.get && req.app.get("socket")) || null;
}

/**
 * Resolve the per-bodyshop RR config strictly from DB.
 * Looks for bodyshopId in:
 *  - req.body.bodyshopId
 *  - req.body.job?.shopid
 *  - x-bodyshop-id header
 * Throws if not found.
 */
async function resolveRRConfigHttp(req) {
  const candidateHeader = req.get && req.get("x-bodyshop-id");
  const body = req.body || {};
  const bodyshopId = body.bodyshopId || (body.job && (body.job.shopid || body.job.bodyshopId)) || candidateHeader;

  if (!bodyshopId) {
    throw new RrApiError(
      "Missing bodyshopId (expected in body.bodyshopId, body.job.shopid, or x-bodyshop-id header)",
      "BAD_REQUEST"
    );
  }

  return getRRConfigForBodyshop(bodyshopId);
}

// -------------------- Customers --------------------

router.post("/rr/customer/insert", async (req, res) => {
  const socket = socketOf(req);
  const { customer } = req.body || {};

  try {
    if (!customer) throw new RrApiError("Missing 'customer' in request body", "BAD_REQUEST");
    const cfg = await resolveRRConfigHttp(req); // DB-driven, required
    const result = await customerApi.insertCustomer(socket, customer, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /customer/insert failed", { err: err.message });
    return fail(res, err);
  }
});

router.post("/rr/customer/update", async (req, res) => {
  const socket = socketOf(req);
  const { customer } = req.body || {};

  try {
    if (!customer) throw new RrApiError("Missing 'customer' in request body", "BAD_REQUEST");
    const cfg = await resolveRRConfigHttp(req);
    const result = await customerApi.updateCustomer(socket, customer, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /customer/update failed", { err: err.message });
    return fail(res, err);
  }
});

// -------------------- Repair Orders --------------------

router.post("/rr/repair-order/create", async (req, res) => {
  const socket = socketOf(req);
  const { job } = req.body || {};

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    const cfg = await resolveRRConfigHttp(req);
    const result = await roApi.createRepairOrder(socket, job, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /repair-order/create failed", { err: err.message });
    return fail(res, err);
  }
});

router.post("/rr/repair-order/update", async (req, res) => {
  const socket = socketOf(req);
  const { job } = req.body || {};

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    const cfg = await resolveRRConfigHttp(req);
    const result = await roApi.updateRepairOrder(socket, job, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /repair-order/update failed", { err: err.message });
    return fail(res, err);
  }
});

// -------------------- Lookups --------------------

router.post("/rr/lookup/advisors", async (req, res) => {
  const socket = socketOf(req);
  const { criteria = {} } = req.body || {};

  try {
    const cfg = await resolveRRConfigHttp(req);
    const result = await lookupApi.getAdvisors(socket, criteria, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /lookup/advisors failed", { err: err.message });
    return fail(res, err);
  }
});

router.post("/rr/lookup/parts", async (req, res) => {
  const socket = socketOf(req);
  const { criteria = {} } = req.body || {};

  try {
    const cfg = await resolveRRConfigHttp(req);
    const result = await lookupApi.getParts(socket, criteria, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /lookup/parts failed", { err: err.message });
    return fail(res, err);
  }
});

router.post("/rr/lookup/combined-search", async (req, res) => {
  const socket = socketOf(req);
  const { criteria = {} } = req.body || {};

  try {
    const cfg = await resolveRRConfigHttp(req);
    const result = await lookupApi.combinedSearch(socket, criteria, cfg);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /lookup/combined-search failed", { err: err.message });
    return fail(res, err);
  }
});

// -------------------- Orchestrated export --------------------

router.post("/rr/export/job", async (req, res) => {
  const socket = socketOf(req);
  const { job, options = {} } = req.body || {};

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    const cfg = await resolveRRConfigHttp(req);
    const result = await exportJobToRome(socket, job, cfg, options);
    return ok(res, result);
  } catch (err) {
    RRLogger(socket, "error", "RR /export/job failed", { err: err.message });
    return fail(res, err);
  }
});

// -------------------- Diagnostics --------------------

router.get("/rr/actions", (_req, res) => {
  try {
    return ok(res, { actions: listActions() });
  } catch (err) {
    return fail(res, err);
  }
});

router.get("/rr/templates/verify", async (_req, res) => {
  try {
    const issues = await verifyTemplatesExist();
    return ok(res, { ok: issues.length === 0, issues });
  } catch (err) {
    return fail(res, err);
  }
});

module.exports = router;