1237 lines
39 KiB
JavaScript
1237 lines
39 KiB
JavaScript
/**
|
||
* THIS IS A COPY of CDKCalculateAllocations, modified to:
|
||
* - Only calculate allocations needed for Reynolds & RR exports
|
||
* - Keep sales broken down into buckets (parts, taxable / non-taxable parts, taxable labor, non-taxable labor, extras)
|
||
* - Add extra logging for easier debugging
|
||
*
|
||
* Original comments follow.
|
||
*/
|
||
|
||
const { GraphQLClient } = require("graphql-request");
|
||
const Dinero = require("dinero.js");
|
||
const _ = require("lodash");
|
||
|
||
const queries = require("../graphql-client/queries");
|
||
const CreateRRLogEvent = require("./rr-logger-event");
|
||
const InstanceManager = require("../utils/instanceMgr").default;
|
||
|
||
const { DiscountNotAlreadyCounted } = InstanceManager({
|
||
imex: require("../job/job-totals"),
|
||
rome: require("../job/job-totals-USA")
|
||
});
|
||
|
||
/**
|
||
* ============================
|
||
* Helpers / Summarizers
|
||
* ============================
|
||
*/
|
||
|
||
const summarizeMoney = (dinero) => {
|
||
if (!dinero || typeof dinero.getAmount !== "function") return { cents: null };
|
||
return { cents: dinero.getAmount() };
|
||
};
|
||
|
||
const summarizeTaxAllocations = (tax) =>
|
||
Object.entries(tax || {}).map(([key, entry]) => ({
|
||
key,
|
||
sale: summarizeMoney(entry?.sale),
|
||
cost: summarizeMoney(entry?.cost)
|
||
}));
|
||
|
||
const summarizeAllocationsArray = (arr) =>
|
||
(arr || []).map((a) => ({
|
||
center: a.center || a.tax || null,
|
||
tax: a.tax || null,
|
||
sale: summarizeMoney(a.sale || a.totalSale || Dinero()),
|
||
cost: summarizeMoney(a.cost)
|
||
}));
|
||
|
||
const toFiniteNumber = (value) => {
|
||
const parsed = Number.parseFloat(value);
|
||
return Number.isFinite(parsed) ? parsed : 0;
|
||
};
|
||
|
||
/**
|
||
* Internal per-center bucket shape for *sales*.
|
||
* We keep separate buckets for RR so we can split
|
||
* taxable vs non-taxable parts and labor lines later.
|
||
*/
|
||
function emptyCenterBucket() {
|
||
const zero = Dinero();
|
||
return {
|
||
// Parts
|
||
partsSale: zero, // total parts (taxable + non-taxable)
|
||
partsTaxableSale: zero, // parts that should be taxed in RR
|
||
partsNonTaxableSale: zero, // parts that should NOT be taxed in RR
|
||
|
||
// Labor
|
||
laborTaxableSale: zero, // labor that should be taxed in RR
|
||
laborNonTaxableSale: zero, // labor that should NOT be taxed in RR
|
||
laborTaxableHours: 0,
|
||
laborNonTaxableHours: 0,
|
||
|
||
// Extras (MAPA/MASH/towing/PAO/etc)
|
||
extrasSale: zero, // total extras (taxable + non-taxable)
|
||
extrasTaxableSale: zero,
|
||
extrasNonTaxableSale: zero
|
||
};
|
||
}
|
||
|
||
function ensureCenterBucket(hash, center) {
|
||
if (!hash[center]) hash[center] = emptyCenterBucket();
|
||
return hash[center];
|
||
}
|
||
|
||
/**
|
||
* Thin logger wrapper: always uses CreateRRLogEvent,
|
||
* with structured data passed via meta arg.
|
||
*/
|
||
function createDebugLogger(connectionData) {
|
||
return (msg, meta, level = "DEBUG") => {
|
||
const baseMsg = "rr-calculate-allocations " + msg;
|
||
CreateRRLogEvent(connectionData, level, baseMsg, meta !== undefined ? meta : undefined);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Query job data for allocations.
|
||
*/
|
||
async function QueryJobData(connectionData, token, jobid) {
|
||
CreateRRLogEvent(connectionData, "DEBUG", "Querying job data for allocations", { jobid });
|
||
|
||
const client = new GraphQLClient(process.env.GRAPHQL_ENDPOINT, {});
|
||
const result = await client.setHeaders({ Authorization: token }).request(queries.GET_CDK_ALLOCATIONS, { id: jobid });
|
||
|
||
return result.jobs_by_pk;
|
||
}
|
||
|
||
/**
|
||
* Build tax allocation object depending on environment (imex vs rome).
|
||
* This matches the original logic, just split into its own helper.
|
||
*/
|
||
function buildTaxAllocations(bodyshop, job) {
|
||
return InstanceManager({
|
||
executeFunction: true,
|
||
deubg: true,
|
||
args: [],
|
||
imex: () => ({
|
||
state: {
|
||
center: bodyshop.md_responsibility_centers.taxes.state.name,
|
||
sale: Dinero(job.job_totals.totals.state_tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.state,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.state
|
||
},
|
||
federal: {
|
||
center: bodyshop.md_responsibility_centers.taxes.federal.name,
|
||
sale: Dinero(job.job_totals.totals.federal_tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.federal,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.federal
|
||
}
|
||
}),
|
||
rome: () => ({
|
||
tax_ty1: {
|
||
center: bodyshop.md_responsibility_centers.taxes.tax_ty1.name,
|
||
sale: Dinero(job.job_totals.totals.us_sales_tax_breakdown.ty1Tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.tax_ty1,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.tax_ty1
|
||
},
|
||
tax_ty2: {
|
||
center: bodyshop.md_responsibility_centers.taxes.tax_ty2.name,
|
||
sale: Dinero(job.job_totals.totals.us_sales_tax_breakdown.ty2Tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.tax_ty2,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.tax_ty2
|
||
},
|
||
tax_ty3: {
|
||
center: bodyshop.md_responsibility_centers.taxes.tax_ty3.name,
|
||
sale: Dinero(job.job_totals.totals.us_sales_tax_breakdown.ty3Tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.tax_ty3,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.tax_ty3
|
||
},
|
||
tax_ty4: {
|
||
center: bodyshop.md_responsibility_centers.taxes.tax_ty4.name,
|
||
sale: Dinero(job.job_totals.totals.us_sales_tax_breakdown.ty4Tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.tax_ty4,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.tax_ty4
|
||
},
|
||
tax_ty5: {
|
||
center: bodyshop.md_responsibility_centers.taxes.tax_ty5.name,
|
||
sale: Dinero(job.job_totals.totals.us_sales_tax_breakdown.ty5Tax),
|
||
cost: Dinero(),
|
||
profitCenter: bodyshop.md_responsibility_centers.taxes.tax_ty5,
|
||
costCenter: bodyshop.md_responsibility_centers.taxes.tax_ty5
|
||
}
|
||
})
|
||
});
|
||
}
|
||
|
||
/**
|
||
* ============================
|
||
* Tax Context & Helpers
|
||
* ============================
|
||
*/
|
||
|
||
/**
|
||
* Build a small "tax context" object from the job + current instance.
|
||
*
|
||
* This centralises all of the "is this category taxable?" logic so that
|
||
* the rest of the allocation code just asks simple yes/no questions.
|
||
*
|
||
* IMPORTANT: we are **not** calculating any tax **amounts** here – that is
|
||
* still handled by job-costing. We only need to know if a given sale bucket
|
||
* should be treated as taxable vs non-taxable for RR (CustTxblNTxblFlag).
|
||
*/
|
||
function buildTaxContext(job = {}) {
|
||
const isImex = !!InstanceManager({ imex: true }); // Canada
|
||
const isRome = !!InstanceManager({ rome: true }); // US
|
||
|
||
const toNumber = (v) => (v == null ? 0 : Number(v) || 0);
|
||
|
||
const federalTaxRate = toNumber(job.federal_tax_rate);
|
||
const stateTaxRate = toNumber(job.state_tax_rate);
|
||
const localTaxRate = toNumber(job.local_tax_rate);
|
||
|
||
const hasFederalRate = federalTaxRate > 0;
|
||
const hasState = stateTaxRate > 0;
|
||
const hasLocal = localTaxRate > 0;
|
||
|
||
// "hasFederal" kept for backwards compatibility / logging (Canada only)
|
||
const hasFederal = isImex && hasFederalRate;
|
||
|
||
// Canada: if ANY of federal / state / local > 0, treat the job as
|
||
// "everything taxable by default", then let line-level flags override
|
||
// for parts where applicable.
|
||
const globalAllTaxCanada = isImex && (hasFederalRate || hasState || hasLocal);
|
||
|
||
const hasAnySalesTax = hasFederalRate || hasState || hasLocal;
|
||
|
||
// Parts tax rate map (PAA/PAC/…)
|
||
let partTaxRates = job.part_tax_rates || job.parts_tax_rates || {};
|
||
if (typeof partTaxRates === "string") {
|
||
try {
|
||
partTaxRates = JSON.parse(partTaxRates);
|
||
} catch {
|
||
partTaxRates = {};
|
||
}
|
||
}
|
||
if (!partTaxRates || typeof partTaxRates !== "object") {
|
||
partTaxRates = {};
|
||
}
|
||
|
||
const tax_lbr_rt = toNumber(job.tax_lbr_rt); // labour
|
||
const tax_paint_mat_rt = toNumber(job.tax_paint_mat_rt || job.tax_paint_mt_rate); // MAPA
|
||
const tax_shop_mat_rt = toNumber(job.tax_shop_mat_rt); // MASH
|
||
const tax_tow_rt = toNumber(job.tax_tow_rt); // towing
|
||
const tax_sub_rt = toNumber(job.tax_sub_rt); // sublet (rarely used directly)
|
||
|
||
const hasAnyPartsWithTax = Object.values(partTaxRates).some(
|
||
(entry) => entry && entry.prt_tax_in && toNumber(entry.prt_tax_rt) > 0
|
||
);
|
||
|
||
const hasAnyTax =
|
||
hasAnySalesTax ||
|
||
tax_lbr_rt > 0 ||
|
||
tax_paint_mat_rt > 0 ||
|
||
tax_shop_mat_rt > 0 ||
|
||
tax_tow_rt > 0 ||
|
||
tax_sub_rt > 0 ||
|
||
hasAnyPartsWithTax;
|
||
|
||
return {
|
||
isImex,
|
||
isRome,
|
||
|
||
federalTaxRate,
|
||
stateTaxRate,
|
||
localTaxRate,
|
||
|
||
hasFederal,
|
||
hasState,
|
||
hasLocal,
|
||
hasAnySalesTax,
|
||
globalAllTaxCanada,
|
||
|
||
partTaxRates,
|
||
tax_lbr_rt,
|
||
tax_paint_mat_rt,
|
||
tax_shop_mat_rt,
|
||
tax_tow_rt,
|
||
tax_sub_rt,
|
||
hasAnyPartsWithTax,
|
||
hasAnyTax
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Resolve the "PA" / part-type code (PAA/PAC/…) from a job line.
|
||
*/
|
||
function resolvePartType(line = {}) {
|
||
return line.part_type || line.partType || line.pa_code || line.pa || null;
|
||
}
|
||
|
||
/**
|
||
* Decide if a *part* line is taxable vs non-taxable for RR.
|
||
*
|
||
* Rules:
|
||
* - Canada (IMEX):
|
||
* - If ANY of federal_tax_rate / state_tax_rate / local_tax_rate > 0
|
||
* => everything is taxable by default (globalAllTaxCanada),
|
||
* unless tax_part is explicitly false.
|
||
* - Otherwise, use part_tax_rates[part_type] (prt_tax_in && prt_tax_rt > 0),
|
||
* with tax_part as final override.
|
||
* - US (ROME):
|
||
* - Use part_tax_rates[part_type] (prt_tax_in && prt_tax_rt > 0),
|
||
* with tax_part as final override.
|
||
*
|
||
* - line.tax_part is treated as the *final* check:
|
||
* - tax_part === false => always non-taxable.
|
||
* - tax_part === true => always taxable, even if we have no table entry.
|
||
*/
|
||
function isPartTaxable(line = {}, taxCtx) {
|
||
if (!taxCtx) return !!line.tax_part;
|
||
|
||
const { globalAllTaxCanada, partTaxRates } = taxCtx;
|
||
|
||
// Explicit per-line override to *not* tax.
|
||
if (typeof line.tax_part === "boolean" && line.tax_part === false) {
|
||
return false;
|
||
}
|
||
|
||
// Canada: any federal/state/local tax rate set => all parts taxable,
|
||
// unless explicitly turned off above.
|
||
if (globalAllTaxCanada) {
|
||
return true;
|
||
}
|
||
|
||
let taxable = false;
|
||
|
||
const partType = resolvePartType(line);
|
||
if (partType && partTaxRates && partTaxRates[partType]) {
|
||
const entry = partTaxRates[partType];
|
||
const rate = Number(entry?.prt_tax_rt || 0);
|
||
const indicator = !!entry?.prt_tax_in;
|
||
taxable = indicator && rate > 0;
|
||
}
|
||
|
||
// tax_part === true is treated as "final yes" even if we didn't find
|
||
// a matching part_tax_rate entry.
|
||
if (typeof line.tax_part === "boolean" && line.tax_part === true) {
|
||
taxable = true;
|
||
}
|
||
|
||
return taxable;
|
||
}
|
||
|
||
/**
|
||
* Decide if *labour* for this job is taxable.
|
||
*
|
||
* - Canada (IMEX):
|
||
* - If ANY of federal_tax_rate / state_tax_rate / local_tax_rate > 0
|
||
* (globalAllTaxCanada) => all labour is taxable.
|
||
* - Else if tax_lbr_rt > 0 => labour taxable.
|
||
* - Else => non-taxable.
|
||
* - US (ROME):
|
||
* - tax_lbr_rt > 0 => labour taxable, otherwise not.
|
||
*/
|
||
function isLaborTaxable(_line, taxCtx) {
|
||
if (!taxCtx) return false;
|
||
const { isImex, globalAllTaxCanada, tax_lbr_rt } = taxCtx;
|
||
|
||
if (isImex && globalAllTaxCanada) return true;
|
||
return tax_lbr_rt > 0;
|
||
}
|
||
|
||
/**
|
||
* Taxability helpers for "extras" buckets.
|
||
* These are all job-level decisions; there are no per-line flags for them
|
||
* in the data we currently work with.
|
||
*
|
||
* Canada: if globalAllTaxCanada is true, we treat these as taxable.
|
||
*/
|
||
function isMapaTaxable(taxCtx) {
|
||
if (!taxCtx) return false;
|
||
const { isImex, globalAllTaxCanada, tax_paint_mat_rt } = taxCtx;
|
||
if (isImex && globalAllTaxCanada) return true;
|
||
return tax_paint_mat_rt > 0;
|
||
}
|
||
|
||
function isMashTaxable(taxCtx) {
|
||
if (!taxCtx) return false;
|
||
const { isImex, globalAllTaxCanada, tax_shop_mat_rt } = taxCtx;
|
||
if (isImex && globalAllTaxCanada) return true;
|
||
return tax_shop_mat_rt > 0;
|
||
}
|
||
|
||
function isTowTaxable(taxCtx) {
|
||
if (!taxCtx) return false;
|
||
const { isImex, globalAllTaxCanada, tax_tow_rt } = taxCtx;
|
||
if (isImex && globalAllTaxCanada) return true;
|
||
return tax_tow_rt > 0;
|
||
}
|
||
|
||
/**
|
||
* Helper to push an "extra" (MAPA/MASH/towing/PAO/etc) amount into the
|
||
* appropriate taxable / non-taxable buckets for a given center.
|
||
*/
|
||
function addExtras(bucket, dineroAmount, isTaxable) {
|
||
if (!bucket || !dineroAmount || typeof dineroAmount.add !== "function") return;
|
||
bucket.extrasSale = bucket.extrasSale.add(dineroAmount);
|
||
if (isTaxable) {
|
||
bucket.extrasTaxableSale = bucket.extrasTaxableSale.add(dineroAmount);
|
||
} else {
|
||
bucket.extrasNonTaxableSale = bucket.extrasNonTaxableSale.add(dineroAmount);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Build profitCenterHash from joblines (parts + labor) and detect MAPA/MASH presence.
|
||
* Now stores *buckets* instead of a single Dinero per center.
|
||
*/
|
||
function buildProfitCenterHash(job, debugLog, taxContext) {
|
||
let hasMapaLine = false;
|
||
let hasMashLine = false;
|
||
|
||
const profitCenterHash = job.joblines.reduce((acc, val) => {
|
||
// MAPA line?
|
||
if (val.db_ref === "936008") {
|
||
if (!hasMapaLine) {
|
||
debugLog("Detected existing MAPA line in joblines", {
|
||
joblineId: val.id,
|
||
db_ref: val.db_ref
|
||
});
|
||
}
|
||
hasMapaLine = true;
|
||
}
|
||
|
||
// MASH line?
|
||
if (val.db_ref === "936007") {
|
||
if (!hasMashLine) {
|
||
debugLog("Detected existing MASH line in joblines", {
|
||
joblineId: val.id,
|
||
db_ref: val.db_ref
|
||
});
|
||
}
|
||
hasMashLine = true;
|
||
}
|
||
|
||
// Parts
|
||
if (val.profitcenter_part) {
|
||
const bucket = ensureCenterBucket(acc, val.profitcenter_part);
|
||
|
||
let amount = Dinero({
|
||
amount: Math.round(val.act_price * 100)
|
||
}).multiply(val.part_qty || 1);
|
||
|
||
const hasDiscount = (val.prt_dsmk_m && val.prt_dsmk_m !== 0) || (val.prt_dsmk_p && val.prt_dsmk_p !== 0);
|
||
|
||
if (hasDiscount && DiscountNotAlreadyCounted(val, job.joblines)) {
|
||
const discount = val.prt_dsmk_m
|
||
? Dinero({ amount: Math.round(val.prt_dsmk_m * 100) })
|
||
: Dinero({
|
||
amount: Math.round(val.act_price * 100)
|
||
})
|
||
.multiply(val.part_qty || 0)
|
||
.percentage(Math.abs(val.prt_dsmk_p || 0))
|
||
.multiply(val.prt_dsmk_p > 0 ? 1 : -1);
|
||
|
||
amount = amount.add(discount);
|
||
}
|
||
|
||
const taxable = isPartTaxable(val, taxContext);
|
||
|
||
if (taxable) {
|
||
bucket.partsTaxableSale = bucket.partsTaxableSale.add(amount);
|
||
} else {
|
||
bucket.partsNonTaxableSale = bucket.partsNonTaxableSale.add(amount);
|
||
}
|
||
|
||
// Keep total parts for compatibility / convenience
|
||
bucket.partsSale = bucket.partsSale.add(amount);
|
||
}
|
||
|
||
// Labor
|
||
if (val.profitcenter_labor && val.mod_lbr_ty) {
|
||
const bucket = ensureCenterBucket(acc, val.profitcenter_labor);
|
||
|
||
const rateKey = `rate_${val.mod_lbr_ty.toLowerCase()}`;
|
||
const rate = job[rateKey];
|
||
const lineHours = toFiniteNumber(val.mod_lb_hrs);
|
||
|
||
const laborAmount = Dinero({
|
||
amount: Math.round(rate * 100)
|
||
}).multiply(val.mod_lb_hrs);
|
||
|
||
if (isLaborTaxable(val, taxContext)) {
|
||
bucket.laborTaxableSale = bucket.laborTaxableSale.add(laborAmount);
|
||
bucket.laborTaxableHours += lineHours;
|
||
} else {
|
||
bucket.laborNonTaxableSale = bucket.laborNonTaxableSale.add(laborAmount);
|
||
bucket.laborNonTaxableHours += lineHours;
|
||
}
|
||
}
|
||
|
||
return acc;
|
||
}, {});
|
||
|
||
debugLog("profitCenterHash after joblines", {
|
||
hasMapaLine,
|
||
hasMashLine,
|
||
centers: Object.entries(profitCenterHash).map(([center, b]) => ({
|
||
center,
|
||
parts: summarizeMoney(b.partsSale),
|
||
partsTaxable: summarizeMoney(b.partsTaxableSale),
|
||
partsNonTaxable: summarizeMoney(b.partsNonTaxableSale),
|
||
laborTaxable: summarizeMoney(b.laborTaxableSale),
|
||
laborNonTaxable: summarizeMoney(b.laborNonTaxableSale),
|
||
laborTaxableHours: b.laborTaxableHours,
|
||
laborNonTaxableHours: b.laborNonTaxableHours,
|
||
extras: summarizeMoney(b.extrasSale),
|
||
extrasTaxable: summarizeMoney(b.extrasTaxableSale),
|
||
extrasNonTaxable: summarizeMoney(b.extrasNonTaxableSale)
|
||
}))
|
||
});
|
||
|
||
return { profitCenterHash, hasMapaLine, hasMashLine };
|
||
}
|
||
|
||
/**
|
||
* Build costCenterHash from bills and timetickets.
|
||
*/
|
||
function buildCostCenterHash(job, selectedDmsAllocationConfig, disablebillwip, debugLog) {
|
||
let costCenterHash = {};
|
||
|
||
// 1) Bills -> costs
|
||
debugLog("disablebillwip flag", { disablebillwip });
|
||
|
||
if (!disablebillwip) {
|
||
costCenterHash = job.bills.reduce((billAcc, bill) => {
|
||
bill.billlines.forEach((line) => {
|
||
const targetCenter = selectedDmsAllocationConfig.costs[line.cost_center];
|
||
if (!targetCenter) return;
|
||
|
||
if (!billAcc[targetCenter]) billAcc[targetCenter] = Dinero();
|
||
|
||
const lineDinero = Dinero({
|
||
amount: Math.round((line.actual_cost || 0) * 100)
|
||
})
|
||
.multiply(line.quantity)
|
||
.multiply(bill.is_credit_memo ? -1 : 1);
|
||
|
||
billAcc[targetCenter] = billAcc[targetCenter].add(lineDinero);
|
||
});
|
||
return billAcc;
|
||
}, {});
|
||
}
|
||
|
||
debugLog("costCenterHash after bills (pre-timetickets)", {
|
||
centers: Object.entries(costCenterHash || {}).map(([center, dinero]) => ({
|
||
center,
|
||
...summarizeMoney(dinero)
|
||
}))
|
||
});
|
||
|
||
// 2) Timetickets -> costs
|
||
job.timetickets.forEach((ticket) => {
|
||
const effectiveHours =
|
||
ticket.employee && ticket.employee.flat_rate ? ticket.productivehrs || 0 : ticket.actualhrs || 0;
|
||
|
||
const ticketTotal = Dinero({
|
||
amount: Math.round(ticket.rate * effectiveHours * 100)
|
||
});
|
||
|
||
const targetCenter = selectedDmsAllocationConfig.costs[ticket.ciecacode];
|
||
if (!targetCenter) return;
|
||
|
||
if (!costCenterHash[targetCenter]) costCenterHash[targetCenter] = Dinero();
|
||
costCenterHash[targetCenter] = costCenterHash[targetCenter].add(ticketTotal);
|
||
});
|
||
|
||
debugLog("costCenterHash after timetickets", {
|
||
centers: Object.entries(costCenterHash || {}).map(([center, dinero]) => ({
|
||
center,
|
||
...summarizeMoney(dinero)
|
||
}))
|
||
});
|
||
|
||
return costCenterHash;
|
||
}
|
||
|
||
/**
|
||
* Add manual MAPA / MASH sales where needed (into extrasSale bucket).
|
||
*/
|
||
function applyMapaMashManualLines({
|
||
job,
|
||
selectedDmsAllocationConfig,
|
||
bodyshop,
|
||
profitCenterHash,
|
||
hasMapaLine,
|
||
hasMashLine,
|
||
debugLog,
|
||
taxContext
|
||
}) {
|
||
// MAPA (paint materials)
|
||
if (!hasMapaLine && job.job_totals.rates.mapa.total.amount > 0) {
|
||
const mapaAccountName = selectedDmsAllocationConfig.profits.MAPA;
|
||
const mapaAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === mapaAccountName);
|
||
|
||
if (mapaAccount) {
|
||
const amount = Dinero(job.job_totals.rates.mapa.total);
|
||
const taxable = isMapaTaxable(taxContext);
|
||
|
||
debugLog("Adding MAPA Line Manually", {
|
||
mapaAccountName,
|
||
amount: summarizeMoney(amount),
|
||
taxable
|
||
});
|
||
|
||
const bucket = ensureCenterBucket(profitCenterHash, mapaAccountName);
|
||
addExtras(bucket, amount, taxable);
|
||
} else {
|
||
debugLog("NO MAPA ACCOUNT FOUND!!", { mapaAccountName });
|
||
}
|
||
}
|
||
|
||
// MASH (shop materials)
|
||
if (!hasMashLine && job.job_totals.rates.mash.total.amount > 0) {
|
||
const mashAccountName = selectedDmsAllocationConfig.profits.MASH;
|
||
const mashAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === mashAccountName);
|
||
|
||
if (mashAccount) {
|
||
const amount = Dinero(job.job_totals.rates.mash.total);
|
||
const taxable = isMashTaxable(taxContext);
|
||
|
||
debugLog("Adding MASH Line Manually", {
|
||
mashAccountName,
|
||
amount: summarizeMoney(amount),
|
||
taxable
|
||
});
|
||
|
||
const bucket = ensureCenterBucket(profitCenterHash, mashAccountName);
|
||
addExtras(bucket, amount, taxable);
|
||
} else {
|
||
debugLog("NO MASH ACCOUNT FOUND!!", { mashAccountName });
|
||
}
|
||
}
|
||
|
||
return profitCenterHash;
|
||
}
|
||
|
||
/**
|
||
* Apply materials costing (MAPA/MASH cost side) when configured.
|
||
*/
|
||
function applyMaterialsCosting({ job, bodyshop, selectedDmsAllocationConfig, costCenterHash, debugLog }) {
|
||
const { cdk_configuration } = bodyshop || {};
|
||
|
||
if (!cdk_configuration?.sendmaterialscosting) return costCenterHash;
|
||
|
||
debugLog("sendmaterialscosting enabled", {
|
||
sendmaterialscosting: cdk_configuration.sendmaterialscosting,
|
||
use_paint_scale_data: job.bodyshop.use_paint_scale_data,
|
||
mixdataLength: job.mixdata?.length || 0
|
||
});
|
||
|
||
const percent = cdk_configuration.sendmaterialscosting;
|
||
|
||
// Paint Mat (MAPA)
|
||
const mapaAccountName = selectedDmsAllocationConfig.costs.MAPA;
|
||
const mapaAccount = bodyshop.md_responsibility_centers.costs.find((c) => c.name === mapaAccountName);
|
||
|
||
if (mapaAccount) {
|
||
if (!costCenterHash[mapaAccountName]) costCenterHash[mapaAccountName] = Dinero();
|
||
|
||
if (job.bodyshop.use_paint_scale_data === true) {
|
||
if (job.mixdata && job.mixdata.length > 0) {
|
||
debugLog("Using mixdata for MAPA cost", {
|
||
mapaAccountName,
|
||
totalliquidcost: job.mixdata[0] && job.mixdata[0].totalliquidcost
|
||
});
|
||
|
||
costCenterHash[mapaAccountName] = costCenterHash[mapaAccountName].add(
|
||
Dinero({
|
||
amount: Math.round(((job.mixdata[0] && job.mixdata[0].totalliquidcost) || 0) * 100)
|
||
})
|
||
);
|
||
} else {
|
||
debugLog("Using percentage of MAPA total (no mixdata)", { mapaAccountName });
|
||
|
||
costCenterHash[mapaAccountName] = costCenterHash[mapaAccountName].add(
|
||
Dinero(job.job_totals.rates.mapa.total).percentage(percent)
|
||
);
|
||
}
|
||
} else {
|
||
debugLog("Using percentage of MAPA total (no paint scale data)", { mapaAccountName });
|
||
|
||
costCenterHash[mapaAccountName] = costCenterHash[mapaAccountName].add(
|
||
Dinero(job.job_totals.rates.mapa.total).percentage(percent)
|
||
);
|
||
}
|
||
} else {
|
||
debugLog("NO MAPA ACCOUNT FOUND (costs)!!", { mapaAccountName });
|
||
}
|
||
|
||
// Shop Mat (MASH)
|
||
const mashAccountName = selectedDmsAllocationConfig.costs.MASH;
|
||
const mashAccount = bodyshop.md_responsibility_centers.costs.find((c) => c.name === mashAccountName);
|
||
|
||
if (mashAccount) {
|
||
debugLog("Adding MASH material costing", { mashAccountName });
|
||
|
||
if (!costCenterHash[mashAccountName]) costCenterHash[mashAccountName] = Dinero();
|
||
costCenterHash[mashAccountName] = costCenterHash[mashAccountName].add(
|
||
Dinero(job.job_totals.rates.mash.total).percentage(percent)
|
||
);
|
||
} else {
|
||
debugLog("NO MASH ACCOUNT FOUND (costs)!!", { mashAccountName });
|
||
}
|
||
|
||
return costCenterHash;
|
||
}
|
||
|
||
/**
|
||
* Apply non-tax extras (PVRT, towing, storage, PAO).
|
||
* Extras go into the extrasSale bucket (split taxable / non-taxable).
|
||
*/
|
||
function applyExtras({
|
||
job,
|
||
bodyshop,
|
||
selectedDmsAllocationConfig,
|
||
profitCenterHash,
|
||
taxAllocations,
|
||
debugLog,
|
||
taxContext
|
||
}) {
|
||
const { ca_bc_pvrt } = job;
|
||
|
||
// BC PVRT -> state tax
|
||
if (ca_bc_pvrt) {
|
||
debugLog("Adding PVRT to state tax allocation", { ca_bc_pvrt });
|
||
|
||
taxAllocations.state.sale = taxAllocations.state.sale.add(Dinero({ amount: Math.round((ca_bc_pvrt || 0) * 100) }));
|
||
}
|
||
|
||
// Towing
|
||
if (job.towing_payable && job.towing_payable !== 0) {
|
||
const towAccountName = selectedDmsAllocationConfig.profits.TOW;
|
||
const towAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === towAccountName);
|
||
|
||
if (towAccount) {
|
||
const amount = Dinero({
|
||
amount: Math.round((job.towing_payable || 0) * 100)
|
||
});
|
||
const taxable = isTowTaxable(taxContext);
|
||
|
||
debugLog("Adding towing_payable to TOW account", {
|
||
towAccountName,
|
||
towing_payable: job.towing_payable,
|
||
taxable
|
||
});
|
||
|
||
const bucket = ensureCenterBucket(profitCenterHash, towAccountName);
|
||
addExtras(bucket, amount, taxable);
|
||
} else {
|
||
debugLog("NO TOW ACCOUNT FOUND!!", { towAccountName });
|
||
}
|
||
}
|
||
|
||
// Storage (shares TOW account)
|
||
if (job.storage_payable && job.storage_payable !== 0) {
|
||
const storageAccountName = selectedDmsAllocationConfig.profits.TOW;
|
||
const towAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === storageAccountName);
|
||
|
||
if (towAccount) {
|
||
const amount = Dinero({
|
||
amount: Math.round((job.storage_payable || 0) * 100)
|
||
});
|
||
const taxable = isTowTaxable(taxContext);
|
||
|
||
debugLog("Adding storage_payable to TOW account", {
|
||
storageAccountName,
|
||
storage_payable: job.storage_payable,
|
||
taxable
|
||
});
|
||
|
||
const bucket = ensureCenterBucket(profitCenterHash, storageAccountName);
|
||
addExtras(bucket, amount, taxable);
|
||
} else {
|
||
debugLog("NO STORAGE/TOW ACCOUNT FOUND!!", { storageAccountName });
|
||
}
|
||
}
|
||
|
||
// Bottom line adjustment -> PAO
|
||
if (job.adjustment_bottom_line && job.adjustment_bottom_line !== 0) {
|
||
const otherAccountName = selectedDmsAllocationConfig.profits.PAO;
|
||
const otherAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === otherAccountName);
|
||
|
||
if (otherAccount) {
|
||
const amount = Dinero({
|
||
amount: Math.round((job.adjustment_bottom_line || 0) * 100)
|
||
});
|
||
const taxable = !!(taxContext && taxContext.hasAnyTax);
|
||
|
||
debugLog("Adding adjustment_bottom_line to PAO", {
|
||
otherAccountName,
|
||
adjustment_bottom_line: job.adjustment_bottom_line,
|
||
taxable
|
||
});
|
||
|
||
const bucket = ensureCenterBucket(profitCenterHash, otherAccountName);
|
||
addExtras(bucket, amount, taxable);
|
||
} else {
|
||
debugLog("NO PAO ACCOUNT FOUND!!", { otherAccountName });
|
||
}
|
||
}
|
||
|
||
return { profitCenterHash, taxAllocations };
|
||
}
|
||
|
||
/**
|
||
* Apply Rome-specific profile adjustments (parts + rates).
|
||
* These also feed into the *sales* buckets.
|
||
*/
|
||
function applyRomeProfileAdjustments({
|
||
job,
|
||
bodyshop,
|
||
selectedDmsAllocationConfig,
|
||
profitCenterHash,
|
||
debugLog,
|
||
connectionData,
|
||
taxContext
|
||
}) {
|
||
// Only relevant for Rome instances
|
||
if (!InstanceManager({ rome: true })) return profitCenterHash;
|
||
|
||
if (!selectedDmsAllocationConfig || !selectedDmsAllocationConfig.profits) {
|
||
debugLog("ROME profile adjustments skipped (no selectedDmsAllocationConfig.profits)");
|
||
return profitCenterHash;
|
||
}
|
||
|
||
const partsAdjustments = job?.job_totals?.parts?.adjustments || {};
|
||
const rateMap = job?.job_totals?.rates || {};
|
||
|
||
debugLog("ROME profile adjustments block entered", {
|
||
partAdjustmentKeys: Object.keys(partsAdjustments),
|
||
rateKeys: Object.keys(rateMap)
|
||
});
|
||
|
||
const extrasTaxable = !!(taxContext && taxContext.hasAnyTax);
|
||
|
||
// Parts adjustments
|
||
Object.keys(partsAdjustments).forEach((key) => {
|
||
const accountName = selectedDmsAllocationConfig.profits[key];
|
||
const otherAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === accountName);
|
||
|
||
if (otherAccount) {
|
||
const bucket = ensureCenterBucket(profitCenterHash, accountName);
|
||
|
||
const adjMoney = Dinero(partsAdjustments[key]);
|
||
addExtras(bucket, adjMoney, extrasTaxable);
|
||
|
||
debugLog("Added parts adjustment", {
|
||
key,
|
||
accountName,
|
||
adjustment: summarizeMoney(adjMoney),
|
||
taxable: extrasTaxable
|
||
});
|
||
} else {
|
||
CreateRRLogEvent(
|
||
connectionData,
|
||
"ERROR",
|
||
"Error encountered in rr-calculate-allocations. Unable to find parts adjustment account.",
|
||
{ accountName, key }
|
||
);
|
||
debugLog("Missing parts adjustment account", { key, accountName });
|
||
}
|
||
});
|
||
|
||
// Labor / materials adjustments (match CDK semantics: check `adjustment`, add `adjustments`)
|
||
Object.keys(rateMap).forEach((key) => {
|
||
const rate = rateMap[key];
|
||
if (!rate || !rate.adjustment) return;
|
||
|
||
const checkMoney = Dinero(rate.adjustment);
|
||
if (checkMoney.isZero()) return;
|
||
|
||
const accountName = selectedDmsAllocationConfig.profits[key.toUpperCase()];
|
||
const otherAccount = bodyshop.md_responsibility_centers.profits.find((c) => c.name === accountName);
|
||
|
||
if (otherAccount) {
|
||
const bucket = ensureCenterBucket(profitCenterHash, accountName);
|
||
|
||
// Note: we intentionally use `rate.adjustments` here to mirror CDK behaviour
|
||
const adjMoney = Dinero(rate.adjustments);
|
||
addExtras(bucket, adjMoney, extrasTaxable);
|
||
|
||
debugLog("Added rate adjustment", {
|
||
key,
|
||
accountName,
|
||
adjustment: summarizeMoney(adjMoney),
|
||
taxable: extrasTaxable
|
||
});
|
||
} else {
|
||
CreateRRLogEvent(
|
||
connectionData,
|
||
"ERROR",
|
||
"Error encountered in rr-calculate-allocations. Unable to find rate adjustment account.",
|
||
{ accountName, key }
|
||
);
|
||
debugLog("Missing rate adjustment account", { key, accountName });
|
||
}
|
||
});
|
||
|
||
return profitCenterHash;
|
||
}
|
||
|
||
/**
|
||
* Build job-level profit/cost allocations for each center.
|
||
* PUBLIC SHAPE (for RR):
|
||
* {
|
||
* center,
|
||
* partsSale,
|
||
* partsTaxableSale,
|
||
* partsNonTaxableSale,
|
||
* laborTaxableSale,
|
||
* laborNonTaxableSale,
|
||
* extrasSale,
|
||
* extrasTaxableSale,
|
||
* extrasNonTaxableSale,
|
||
* totalSale,
|
||
* cost,
|
||
* profitCenter,
|
||
* costCenter
|
||
* }
|
||
*/
|
||
function buildJobAllocations(bodyshop, profitCenterHash, costCenterHash, debugLog) {
|
||
const centers = _.union(Object.keys(profitCenterHash), Object.keys(costCenterHash));
|
||
|
||
const jobAllocations = centers.map((center) => {
|
||
const bucket = profitCenterHash[center] || emptyCenterBucket();
|
||
|
||
const extrasSale = bucket.extrasSale;
|
||
const totalSale = bucket.partsSale.add(bucket.laborTaxableSale).add(bucket.laborNonTaxableSale).add(extrasSale);
|
||
|
||
const profitCenter = bodyshop.md_responsibility_centers.profits.find((c) => c.name === center);
|
||
const costCenter = bodyshop.md_responsibility_centers.costs.find((c) => c.name === center);
|
||
|
||
return {
|
||
center,
|
||
|
||
// Parts
|
||
partsSale: bucket.partsSale,
|
||
partsTaxableSale: bucket.partsTaxableSale,
|
||
partsNonTaxableSale: bucket.partsNonTaxableSale,
|
||
|
||
// Labor
|
||
laborTaxableSale: bucket.laborTaxableSale,
|
||
laborNonTaxableSale: bucket.laborNonTaxableSale,
|
||
laborTaxableHours: bucket.laborTaxableHours,
|
||
laborNonTaxableHours: bucket.laborNonTaxableHours,
|
||
|
||
// Extras
|
||
extrasSale,
|
||
extrasTaxableSale: bucket.extrasTaxableSale,
|
||
extrasNonTaxableSale: bucket.extrasNonTaxableSale,
|
||
|
||
totalSale,
|
||
|
||
cost: costCenterHash[center] || Dinero(),
|
||
|
||
profitCenter,
|
||
costCenter
|
||
};
|
||
});
|
||
|
||
debugLog(
|
||
"jobAllocations built",
|
||
jobAllocations.map((row) => ({
|
||
center: row.center,
|
||
parts: summarizeMoney(row.partsSale),
|
||
partsTaxable: summarizeMoney(row.partsTaxableSale),
|
||
partsNonTaxable: summarizeMoney(row.partsNonTaxableSale),
|
||
laborTaxable: summarizeMoney(row.laborTaxableSale),
|
||
laborNonTaxable: summarizeMoney(row.laborNonTaxableSale),
|
||
extras: summarizeMoney(row.extrasSale),
|
||
extrasTaxable: summarizeMoney(row.extrasTaxableSale),
|
||
extrasNonTaxable: summarizeMoney(row.extrasNonTaxableSale),
|
||
totalSale: summarizeMoney(row.totalSale),
|
||
cost: summarizeMoney(row.cost)
|
||
}))
|
||
);
|
||
|
||
return jobAllocations;
|
||
}
|
||
|
||
/**
|
||
* Build tax allocations array from taxAllocations hash.
|
||
* Shape is unchanged from original (except extra logging).
|
||
*/
|
||
function buildTaxAllocArray(taxAllocations, selectedDmsAllocationConfig, debugLog) {
|
||
const taxAllocArray = Object.keys(taxAllocations)
|
||
.filter((key) => taxAllocations[key].sale.getAmount() > 0 || taxAllocations[key].cost.getAmount() > 0)
|
||
.map((key) => {
|
||
if (
|
||
key === "federal" &&
|
||
selectedDmsAllocationConfig.gst_override &&
|
||
selectedDmsAllocationConfig.gst_override !== ""
|
||
) {
|
||
const ret = { ...taxAllocations[key], tax: key };
|
||
ret.costCenter.dms_acctnumber = selectedDmsAllocationConfig.gst_override;
|
||
ret.profitCenter.dms_acctnumber = selectedDmsAllocationConfig.gst_override;
|
||
return ret;
|
||
}
|
||
return { ...taxAllocations[key], tax: key };
|
||
});
|
||
|
||
debugLog("taxAllocArray built", summarizeAllocationsArray(taxAllocArray));
|
||
return taxAllocArray;
|
||
}
|
||
|
||
/**
|
||
* Build adjustment allocations (ttl_adjustment + ttl_tax_adjustment).
|
||
*/
|
||
function buildAdjustmentAllocations(job, bodyshop, debugLog) {
|
||
const ttlAdjArray = job.job_totals.totals.ttl_adjustment
|
||
? [
|
||
{
|
||
center: "SUB ADJ",
|
||
sale: Dinero(job.job_totals.totals.ttl_adjustment),
|
||
cost: Dinero(),
|
||
profitCenter: {
|
||
name: "SUB ADJ",
|
||
accountdesc: "SUB ADJ",
|
||
accountitem: "SUB ADJ",
|
||
accountname: "SUB ADJ",
|
||
dms_acctnumber: bodyshop.md_responsibility_centers.ttl_adjustment.dms_acctnumber
|
||
},
|
||
costCenter: {}
|
||
}
|
||
]
|
||
: [];
|
||
|
||
const ttlTaxAdjArray = job.job_totals.totals.ttl_tax_adjustment
|
||
? [
|
||
{
|
||
center: "TAX ADJ",
|
||
sale: Dinero(job.job_totals.totals.ttl_tax_adjustment),
|
||
cost: Dinero(),
|
||
profitCenter: {
|
||
name: "TAX ADJ",
|
||
accountdesc: "TAX ADJ",
|
||
accountitem: "TAX ADJ",
|
||
accountname: "TAX ADJ",
|
||
dms_acctnumber: bodyshop.md_responsibility_centers.ttl_tax_adjustment.dms_acctnumber
|
||
},
|
||
costCenter: {}
|
||
}
|
||
]
|
||
: [];
|
||
|
||
if (ttlAdjArray.length) {
|
||
debugLog("ttl_adjustment allocation added", summarizeAllocationsArray(ttlAdjArray));
|
||
}
|
||
if (ttlTaxAdjArray.length) {
|
||
debugLog("ttl_tax_adjustment allocation added", summarizeAllocationsArray(ttlTaxAdjArray));
|
||
}
|
||
|
||
return { ttlAdjArray, ttlTaxAdjArray };
|
||
}
|
||
|
||
/**
|
||
* Core allocation calculation – RR-only, with bucketed sales.
|
||
*
|
||
* RETURN SHAPE:
|
||
* {
|
||
* jobAllocations, // per-center buckets (see buildJobAllocations)
|
||
* taxAllocArray, // tax allocations
|
||
* ttlAdjArray, // ttl_adjustment allocations
|
||
* ttlTaxAdjArray // ttl_tax_adjustment allocations
|
||
* }
|
||
*/
|
||
function calculateAllocations(connectionData, job) {
|
||
const { bodyshop } = job;
|
||
const debugLog = createDebugLogger(connectionData);
|
||
|
||
debugLog("ENTER", {
|
||
bodyshopId: bodyshop?.id,
|
||
bodyshopName: bodyshop?.name,
|
||
dms_allocation: job.dms_allocation,
|
||
hasBills: Array.isArray(job.bills) ? job.bills.length : 0,
|
||
joblines: Array.isArray(job.joblines) ? job.joblines.length : 0,
|
||
timetickets: Array.isArray(job.timetickets) ? job.timetickets.length : 0
|
||
});
|
||
|
||
const taxContext = buildTaxContext(job);
|
||
debugLog("Tax context initialised", {
|
||
isImex: taxContext.isImex,
|
||
isRome: taxContext.isRome,
|
||
federalTaxRate: taxContext.federalTaxRate,
|
||
stateTaxRate: taxContext.stateTaxRate,
|
||
localTaxRate: taxContext.localTaxRate,
|
||
hasFederal: taxContext.hasFederal,
|
||
hasState: taxContext.hasState,
|
||
hasLocal: taxContext.hasLocal,
|
||
globalAllTaxCanada: taxContext.globalAllTaxCanada,
|
||
tax_lbr_rt: taxContext.tax_lbr_rt,
|
||
tax_paint_mat_rt: taxContext.tax_paint_mat_rt,
|
||
tax_shop_mat_rt: taxContext.tax_shop_mat_rt,
|
||
tax_tow_rt: taxContext.tax_tow_rt,
|
||
hasAnyPartsWithTax: taxContext.hasAnyPartsWithTax,
|
||
hasAnyTax: taxContext.hasAnyTax
|
||
});
|
||
|
||
// 1) Tax allocations
|
||
let taxAllocations = buildTaxAllocations(bodyshop, job);
|
||
debugLog("Initial taxAllocations", summarizeTaxAllocations(taxAllocations));
|
||
|
||
// 2) Profit centers from job lines + MAPA/MASH detection
|
||
const {
|
||
profitCenterHash: initialProfitHash,
|
||
hasMapaLine,
|
||
hasMashLine
|
||
} = buildProfitCenterHash(job, debugLog, taxContext);
|
||
|
||
// 3) DMS allocation config
|
||
const selectedDmsAllocationConfig =
|
||
bodyshop.md_responsibility_centers.dms_defaults.find((d) => d.name === job.dms_allocation) || null;
|
||
|
||
CreateRRLogEvent(connectionData, "DEBUG", "Using DMS Allocation for cost export", {
|
||
allocationName: selectedDmsAllocationConfig && selectedDmsAllocationConfig.name
|
||
});
|
||
debugLog("Selected DMS allocation config", {
|
||
name: selectedDmsAllocationConfig && selectedDmsAllocationConfig.name
|
||
});
|
||
|
||
// 4) Cost centers from bills and timetickets
|
||
const disablebillwip = !!bodyshop?.pbs_configuration?.disablebillwip;
|
||
let costCenterHash = buildCostCenterHash(job, selectedDmsAllocationConfig, disablebillwip, debugLog);
|
||
|
||
// 5) Manual MAPA/MASH sales (when needed)
|
||
let profitCenterHash = applyMapaMashManualLines({
|
||
job,
|
||
selectedDmsAllocationConfig,
|
||
bodyshop,
|
||
profitCenterHash: initialProfitHash,
|
||
hasMapaLine,
|
||
hasMashLine,
|
||
debugLog,
|
||
taxContext
|
||
});
|
||
|
||
// 6) Materials costing (MAPA/MASH cost side)
|
||
costCenterHash = applyMaterialsCosting({
|
||
job,
|
||
bodyshop,
|
||
selectedDmsAllocationConfig,
|
||
costCenterHash,
|
||
debugLog
|
||
});
|
||
|
||
// 7) PVRT / towing / storage / PAO extras
|
||
({ profitCenterHash, taxAllocations } = applyExtras({
|
||
job,
|
||
bodyshop,
|
||
selectedDmsAllocationConfig,
|
||
profitCenterHash,
|
||
taxAllocations,
|
||
debugLog,
|
||
taxContext
|
||
}));
|
||
|
||
// 8) Rome-only profile-level adjustments
|
||
profitCenterHash = applyRomeProfileAdjustments({
|
||
job,
|
||
bodyshop,
|
||
selectedDmsAllocationConfig,
|
||
profitCenterHash,
|
||
debugLog,
|
||
connectionData,
|
||
taxContext
|
||
});
|
||
|
||
debugLog("profitCenterHash before jobAllocations build", {
|
||
centers: Object.entries(profitCenterHash || {}).map(([center, b]) => ({
|
||
center,
|
||
parts: summarizeMoney(b.partsSale),
|
||
partsTaxable: summarizeMoney(b.partsTaxableSale),
|
||
partsNonTaxable: summarizeMoney(b.partsNonTaxableSale),
|
||
laborTaxable: summarizeMoney(b.laborTaxableSale),
|
||
laborNonTaxable: summarizeMoney(b.laborNonTaxableSale),
|
||
extras: summarizeMoney(b.extrasSale),
|
||
extrasTaxable: summarizeMoney(b.extrasTaxableSale),
|
||
extrasNonTaxable: summarizeMoney(b.extrasNonTaxableSale)
|
||
}))
|
||
});
|
||
debugLog("costCenterHash before jobAllocations build", {
|
||
centers: Object.entries(costCenterHash || {}).map(([center, dinero]) => ({
|
||
center,
|
||
...summarizeMoney(dinero)
|
||
}))
|
||
});
|
||
|
||
// 9) Build job-level allocations & tax allocations
|
||
const jobAllocations = buildJobAllocations(bodyshop, profitCenterHash, costCenterHash, debugLog);
|
||
const taxAllocArray = buildTaxAllocArray(taxAllocations, selectedDmsAllocationConfig, debugLog);
|
||
const { ttlAdjArray, ttlTaxAdjArray } = buildAdjustmentAllocations(job, bodyshop, debugLog);
|
||
|
||
const result = {
|
||
jobAllocations,
|
||
taxAllocArray,
|
||
ttlAdjArray,
|
||
ttlTaxAdjArray
|
||
};
|
||
|
||
debugLog("FINAL allocations summary", {
|
||
jobAllocationsCount: jobAllocations.length,
|
||
taxAllocCount: taxAllocArray.length,
|
||
ttlAdjCount: ttlAdjArray.length,
|
||
ttlTaxAdjCount: ttlTaxAdjArray.length
|
||
});
|
||
debugLog("EXIT");
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* HTTP route wrapper (kept for compatibility; still logs via RR logger).
|
||
* Responds with { data: { jobAllocations, taxAllocArray, ttlAdjArray, ttlTaxAdjArray } }
|
||
*/
|
||
exports.defaultRoute = async function (req, res) {
|
||
try {
|
||
CreateRRLogEvent(req, "DEBUG", "Received request to calculate allocations", { jobid: req.body.jobid });
|
||
|
||
const jobData = await QueryJobData(req, req.BearerToken, req.body.jobid);
|
||
const data = calculateAllocations(req, jobData);
|
||
return res.status(200).json({ data });
|
||
} catch (error) {
|
||
CreateRRLogEvent(req, "ERROR", "Error encountered in rr-calculate-allocations.", {
|
||
message: error?.message || String(error),
|
||
stack: error?.stack
|
||
});
|
||
res.status(500).json({ error: `Error encountered in rr-calculate-allocations. ${error}` });
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Socket entry point (what rr-job-export & rr-register-socket-events call).
|
||
* Reynolds-only: WSS + RR logger.
|
||
*
|
||
* Returns the same object as calculateAllocations().
|
||
*/
|
||
exports.default = async function (socket, jobid) {
|
||
try {
|
||
const token = `Bearer ${socket.handshake.auth.token}`;
|
||
const jobData = await QueryJobData(socket, token, jobid);
|
||
return calculateAllocations(socket, jobData);
|
||
} catch (error) {
|
||
CreateRRLogEvent(socket, "ERROR", "Error encountered in rr-calculate-allocations.", {
|
||
message: error?.message || String(error),
|
||
stack: error?.stack
|
||
});
|
||
return null;
|
||
}
|
||
};
|