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");

// 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 pickConfig(req) {
  // Accept config in either { config } or { bodyshopConfig }
  return req.body?.config || req.body?.bodyshopConfig || {};
}
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;
}

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

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

  try {
    if (!customer) throw new RrApiError("Missing 'customer' in request body", "BAD_REQUEST");
    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 || {};
  const cfg = pickConfig(req);

  try {
    if (!customer) throw new RrApiError("Missing 'customer' in request body", "BAD_REQUEST");
    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 || {};
  const cfg = pickConfig(req);

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    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 || {};
  const cfg = pickConfig(req);

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    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 || {};
  const cfg = pickConfig(req);

  try {
    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 || {};
  const cfg = pickConfig(req);

  try {
    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 || {};
  const cfg = pickConfig(req);

  try {
    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 || {};
  const cfg = pickConfig(req);

  try {
    if (!job) throw new RrApiError("Missing 'job' in request body", "BAD_REQUEST");
    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;