577 lines
20 KiB
JavaScript
577 lines
20 KiB
JavaScript
const express = require('express');
|
|
const { DateTime } = require('luxon');
|
|
const { getDbConnection } = require('../db/connection');
|
|
|
|
const router = express.Router();
|
|
|
|
// Bucket boundaries by summary_subtotal (post-item-sale, pre-order-promo).
|
|
// The final entry is open-ended: all orders >= the last bound land there.
|
|
const RANGE_BOUNDS = [
|
|
10, 20, 30, 40, 50, 60, 70, 80, 90,
|
|
100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
|
|
300, 400, 500, 1000, 1500
|
|
];
|
|
|
|
const FINAL_BUCKET_KEY = '99999';
|
|
|
|
function buildRangeDefinitions() {
|
|
const ranges = [];
|
|
let previous = 0;
|
|
for (const bound of RANGE_BOUNDS) {
|
|
const key = bound.toString().padStart(5, '0');
|
|
ranges.push({
|
|
min: previous,
|
|
max: bound,
|
|
label: `$${previous.toLocaleString()} - $${bound.toLocaleString()}`,
|
|
key,
|
|
});
|
|
previous = bound;
|
|
}
|
|
const lastBound = RANGE_BOUNDS[RANGE_BOUNDS.length - 1];
|
|
ranges.push({
|
|
min: lastBound,
|
|
max: null,
|
|
label: `$${lastBound.toLocaleString()}+`,
|
|
key: FINAL_BUCKET_KEY,
|
|
});
|
|
return ranges;
|
|
}
|
|
|
|
const RANGE_DEFINITIONS = buildRangeDefinitions();
|
|
|
|
function bucketKeyFor(subtotal) {
|
|
for (const range of RANGE_DEFINITIONS) {
|
|
if (range.max == null) return range.key;
|
|
if (subtotal <= range.max) return range.key;
|
|
}
|
|
return FINAL_BUCKET_KEY;
|
|
}
|
|
|
|
const DEFAULT_POINT_DOLLAR_VALUE = 0.005;
|
|
|
|
const DEFAULTS = {
|
|
merchantFeePercent: 2.9,
|
|
fixedCostPerOrder: 1.25,
|
|
pointDollarValue: DEFAULT_POINT_DOLLAR_VALUE,
|
|
};
|
|
|
|
function parseDate(value, fallback) {
|
|
if (!value) {
|
|
return fallback;
|
|
}
|
|
const parsed = DateTime.fromISO(value);
|
|
if (!parsed.isValid) {
|
|
return fallback;
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
function formatDateForSql(dt) {
|
|
return dt.toFormat('yyyy-LL-dd HH:mm:ss');
|
|
}
|
|
|
|
router.get('/promos', async (req, res) => {
|
|
let connection;
|
|
try {
|
|
const { connection: conn, release } = await getDbConnection();
|
|
connection = conn;
|
|
const releaseConnection = release;
|
|
|
|
const { startDate, endDate } = req.query || {};
|
|
const now = DateTime.now().endOf('day');
|
|
const defaultStart = now.minus({ years: 3 }).startOf('day');
|
|
|
|
const parsedStart = startDate ? parseDate(startDate, defaultStart).startOf('day') : defaultStart;
|
|
const parsedEnd = endDate ? parseDate(endDate, now).endOf('day') : now;
|
|
|
|
const rangeStart = parsedStart <= parsedEnd ? parsedStart : parsedEnd;
|
|
const rangeEnd = parsedEnd >= parsedStart ? parsedEnd : parsedStart;
|
|
|
|
const rangeStartSql = formatDateForSql(rangeStart);
|
|
const rangeEndSql = formatDateForSql(rangeEnd);
|
|
|
|
const sql = `
|
|
SELECT
|
|
p.promo_id AS id,
|
|
p.promo_code AS code,
|
|
p.promo_description_online AS description_online,
|
|
p.promo_description_private AS description_private,
|
|
p.date_start,
|
|
p.date_end,
|
|
COALESCE(u.usage_count, 0) AS usage_count
|
|
FROM promos p
|
|
LEFT JOIN (
|
|
SELECT
|
|
discount_code,
|
|
COUNT(DISTINCT order_id) AS usage_count
|
|
FROM order_discounts
|
|
WHERE discount_type = 10 AND discount_active = 1
|
|
GROUP BY discount_code
|
|
) u ON u.discount_code = p.promo_id
|
|
WHERE p.date_start IS NOT NULL
|
|
AND p.date_end IS NOT NULL
|
|
AND NOT (p.date_end < ? OR p.date_start > ?)
|
|
AND p.store = 1
|
|
AND p.date_start >= '2010-01-01'
|
|
ORDER BY p.promo_id DESC
|
|
LIMIT 200
|
|
`;
|
|
|
|
const [rows] = await connection.execute(sql, [rangeStartSql, rangeEndSql]);
|
|
releaseConnection();
|
|
|
|
const promos = rows.map(row => ({
|
|
id: Number(row.id),
|
|
code: row.code,
|
|
description: row.description_online || row.description_private || '',
|
|
privateDescription: row.description_private || '',
|
|
promo_description_online: row.description_online || '',
|
|
promo_description_private: row.description_private || '',
|
|
dateStart: row.date_start,
|
|
dateEnd: row.date_end,
|
|
usageCount: Number(row.usage_count || 0)
|
|
}));
|
|
|
|
res.json({ promos });
|
|
} catch (error) {
|
|
if (connection) {
|
|
try {
|
|
connection.destroy();
|
|
} catch (destroyError) {
|
|
console.error('Failed to destroy connection after error:', destroyError);
|
|
}
|
|
}
|
|
console.error('Error fetching promos:', error);
|
|
res.status(500).json({ error: 'Failed to fetch promos' });
|
|
}
|
|
});
|
|
|
|
function emptyBucketAccumulator(range) {
|
|
return {
|
|
key: range.key,
|
|
label: range.label,
|
|
min: range.min,
|
|
max: range.max,
|
|
orderCount: 0,
|
|
sumOrderValue: 0,
|
|
sumProductDiscountAmount: 0,
|
|
sumPromoProductDiscount: 0,
|
|
sumCustomerItemCost: 0,
|
|
sumShippingChargeBase: 0,
|
|
sumShippingAfterAuto: 0,
|
|
sumShipPromoDiscount: 0,
|
|
sumShippingSurcharge: 0,
|
|
sumOrderSurcharge: 0,
|
|
sumCustomerShipCost: 0,
|
|
sumActualShippingCost: 0,
|
|
sumTotalRevenue: 0,
|
|
sumProductCogs: 0,
|
|
sumMerchantFees: 0,
|
|
sumPointsCost: 0,
|
|
sumFixedCosts: 0,
|
|
sumTotalCosts: 0,
|
|
sumProfit: 0,
|
|
};
|
|
}
|
|
|
|
function simulateOrder(order, config, derived) {
|
|
const orderValue = Number(order.summary_subtotal) || 0;
|
|
const retail = Number(order.summary_subtotal_retail) || orderValue;
|
|
const productDiscountAmount = Number(order.summary_discount_subtotal) || 0;
|
|
const pointsRedeemedDollars = Number(order.points_redeemed) || 0;
|
|
// summary_discount_subtotal is a kitchen-sink rollup that includes points
|
|
// redemptions (type 20). pointsCost already accrues for points awarded, so
|
|
// the points portion of historical discount must be excluded here to avoid
|
|
// double-counting it on orders that redeemed points.
|
|
const historicalProductDiscountExPoints = Math.max(0, productDiscountAmount - pointsRedeemedDollars);
|
|
const shippingChargeBase =
|
|
(Number(order.summary_shipping) || 0) + (Number(order.summary_shipping_rush) || 0);
|
|
const actualShippingCost = Number(order.ship_method_cost) || 0;
|
|
const cogs = Number(order.total_cogs) || 0;
|
|
|
|
let promoProductDiscount = 0;
|
|
if (config.productPromo.type === 'percentage_subtotal' && orderValue >= config.productPromo.minSubtotal) {
|
|
promoProductDiscount = orderValue * (config.productPromo.value / 100);
|
|
} else if (config.productPromo.type === 'percentage_regular' && orderValue >= config.productPromo.minSubtotal) {
|
|
const targetRate = config.productPromo.value / 100;
|
|
const targetCustomerPrice = retail * (1 - targetRate);
|
|
promoProductDiscount = Math.max(0, orderValue - targetCustomerPrice);
|
|
} else if (config.productPromo.type === 'fixed_amount' && orderValue >= config.productPromo.minSubtotal) {
|
|
promoProductDiscount = config.productPromo.value;
|
|
} else if (config.productPromo.type === 'none' && config.applyHistoricalProductPromo) {
|
|
promoProductDiscount = historicalProductDiscountExPoints;
|
|
}
|
|
promoProductDiscount = Math.max(0, Math.min(promoProductDiscount, orderValue));
|
|
|
|
let shippingAfterAuto = shippingChargeBase;
|
|
for (const tier of config.shippingTiers) {
|
|
if (orderValue >= tier.threshold) {
|
|
if (tier.mode === 'percentage') {
|
|
shippingAfterAuto = shippingChargeBase * Math.max(0, 1 - tier.value / 100);
|
|
} else if (tier.mode === 'flat') {
|
|
shippingAfterAuto = tier.value;
|
|
}
|
|
}
|
|
}
|
|
|
|
let shipPromoDiscount = 0;
|
|
if (config.shippingPromo.type !== 'none' && orderValue >= config.shippingPromo.minSubtotal) {
|
|
if (config.shippingPromo.type === 'percentage') {
|
|
shipPromoDiscount = shippingAfterAuto * (config.shippingPromo.value / 100);
|
|
} else if (config.shippingPromo.type === 'fixed') {
|
|
shipPromoDiscount = config.shippingPromo.value;
|
|
}
|
|
if (config.shippingPromo.maxDiscount > 0) {
|
|
shipPromoDiscount = Math.min(shipPromoDiscount, config.shippingPromo.maxDiscount);
|
|
}
|
|
shipPromoDiscount = Math.min(shipPromoDiscount, shippingAfterAuto);
|
|
}
|
|
|
|
let shippingSurcharge = 0;
|
|
let orderSurcharge = 0;
|
|
for (const surcharge of config.surcharges) {
|
|
const meetsMin = orderValue >= surcharge.threshold;
|
|
const meetsMax = surcharge.maxThreshold == null || orderValue < surcharge.maxThreshold;
|
|
if (meetsMin && meetsMax) {
|
|
if (surcharge.target === 'shipping') shippingSurcharge += surcharge.amount;
|
|
else if (surcharge.target === 'order') orderSurcharge += surcharge.amount;
|
|
}
|
|
}
|
|
|
|
const customerShipCost = Math.max(0, shippingAfterAuto - shipPromoDiscount + shippingSurcharge);
|
|
const customerItemCost = Math.max(0, orderValue - promoProductDiscount + orderSurcharge);
|
|
const totalRevenue = customerItemCost + customerShipCost;
|
|
|
|
const productCogs = config.cogsCalculationMode === 'average'
|
|
? orderValue * derived.overallCogsPercentage
|
|
: cogs;
|
|
|
|
const merchantFees = totalRevenue * (config.merchantFeePercent / 100);
|
|
const pointsCost = orderValue * derived.pointsPerDollar * derived.redemptionRate * derived.pointDollarValue;
|
|
const fixedCosts = config.fixedCostPerOrder;
|
|
const totalCosts = productCogs + actualShippingCost + merchantFees + pointsCost + fixedCosts;
|
|
const profit = totalRevenue - totalCosts;
|
|
|
|
return {
|
|
orderValue,
|
|
productDiscountAmount,
|
|
promoProductDiscount,
|
|
customerItemCost,
|
|
shippingChargeBase,
|
|
shippingAfterAuto,
|
|
shipPromoDiscount,
|
|
shippingSurcharge,
|
|
orderSurcharge,
|
|
customerShipCost,
|
|
actualShippingCost,
|
|
totalRevenue,
|
|
productCogs,
|
|
merchantFees,
|
|
pointsCost,
|
|
fixedCosts,
|
|
totalCosts,
|
|
profit,
|
|
};
|
|
}
|
|
|
|
function accumulate(bucket, sim) {
|
|
bucket.orderCount += 1;
|
|
bucket.sumOrderValue += sim.orderValue;
|
|
bucket.sumProductDiscountAmount += sim.productDiscountAmount;
|
|
bucket.sumPromoProductDiscount += sim.promoProductDiscount;
|
|
bucket.sumCustomerItemCost += sim.customerItemCost;
|
|
bucket.sumShippingChargeBase += sim.shippingChargeBase;
|
|
bucket.sumShippingAfterAuto += sim.shippingAfterAuto;
|
|
bucket.sumShipPromoDiscount += sim.shipPromoDiscount;
|
|
bucket.sumShippingSurcharge += sim.shippingSurcharge;
|
|
bucket.sumOrderSurcharge += sim.orderSurcharge;
|
|
bucket.sumCustomerShipCost += sim.customerShipCost;
|
|
bucket.sumActualShippingCost += sim.actualShippingCost;
|
|
bucket.sumTotalRevenue += sim.totalRevenue;
|
|
bucket.sumProductCogs += sim.productCogs;
|
|
bucket.sumMerchantFees += sim.merchantFees;
|
|
bucket.sumPointsCost += sim.pointsCost;
|
|
bucket.sumFixedCosts += sim.fixedCosts;
|
|
bucket.sumTotalCosts += sim.totalCosts;
|
|
bucket.sumProfit += sim.profit;
|
|
}
|
|
|
|
function finalizeBucket(b, totalOrders) {
|
|
const n = b.orderCount;
|
|
const avg = (sum) => (n > 0 ? sum / n : 0);
|
|
return {
|
|
key: b.key,
|
|
label: b.label,
|
|
min: b.min,
|
|
max: b.max,
|
|
orderCount: n,
|
|
weight: totalOrders > 0 ? n / totalOrders : 0,
|
|
orderValue: avg(b.sumOrderValue),
|
|
productDiscountAmount: avg(b.sumProductDiscountAmount),
|
|
promoProductDiscount: avg(b.sumPromoProductDiscount),
|
|
customerItemCost: avg(b.sumCustomerItemCost),
|
|
shippingChargeBase: avg(b.sumShippingChargeBase),
|
|
shippingAfterAuto: avg(b.sumShippingAfterAuto),
|
|
shipPromoDiscount: avg(b.sumShipPromoDiscount),
|
|
shippingSurcharge: avg(b.sumShippingSurcharge),
|
|
orderSurcharge: avg(b.sumOrderSurcharge),
|
|
customerShipCost: avg(b.sumCustomerShipCost),
|
|
actualShippingCost: avg(b.sumActualShippingCost),
|
|
totalRevenue: avg(b.sumTotalRevenue),
|
|
productCogs: avg(b.sumProductCogs),
|
|
merchantFees: avg(b.sumMerchantFees),
|
|
pointsCost: avg(b.sumPointsCost),
|
|
fixedCosts: avg(b.sumFixedCosts),
|
|
totalCosts: avg(b.sumTotalCosts),
|
|
profit: avg(b.sumProfit),
|
|
profitPercent: b.sumTotalRevenue > 0 ? b.sumProfit / b.sumTotalRevenue : 0,
|
|
};
|
|
}
|
|
|
|
router.post('/simulate', async (req, res) => {
|
|
const {
|
|
dateRange = {},
|
|
filters = {},
|
|
productPromo = {},
|
|
shippingPromo = {},
|
|
shippingTiers = [],
|
|
surcharges = [],
|
|
merchantFeePercent,
|
|
fixedCostPerOrder,
|
|
cogsCalculationMode = 'actual',
|
|
applyHistoricalProductPromo = false,
|
|
pointsConfig = {}
|
|
} = req.body || {};
|
|
|
|
const endDefault = DateTime.now();
|
|
const startDefault = endDefault.minus({ months: 6 });
|
|
const startDt = parseDate(dateRange.start, startDefault).startOf('day');
|
|
const endDt = parseDate(dateRange.end, endDefault).endOf('day');
|
|
|
|
const shipCountry = filters.shipCountry || 'US';
|
|
const promoIds = Array.from(
|
|
new Set(
|
|
[
|
|
...(Array.isArray(filters.promoIds) ? filters.promoIds : []),
|
|
...(Array.isArray(filters.promoCodes) ? filters.promoCodes : []),
|
|
]
|
|
.map((value) => {
|
|
if (typeof value === 'string') return value.trim();
|
|
if (typeof value === 'number') return String(value);
|
|
return '';
|
|
})
|
|
.filter((value) => value.length > 0)
|
|
)
|
|
);
|
|
|
|
const config = {
|
|
merchantFeePercent: typeof merchantFeePercent === 'number' ? merchantFeePercent : DEFAULTS.merchantFeePercent,
|
|
fixedCostPerOrder: typeof fixedCostPerOrder === 'number' ? fixedCostPerOrder : DEFAULTS.fixedCostPerOrder,
|
|
cogsCalculationMode,
|
|
applyHistoricalProductPromo: applyHistoricalProductPromo === true,
|
|
productPromo: {
|
|
type: productPromo.type || 'none',
|
|
value: Number(productPromo.value || 0),
|
|
minSubtotal: Number(productPromo.minSubtotal || 0)
|
|
},
|
|
shippingPromo: {
|
|
type: shippingPromo.type || 'none',
|
|
value: Number(shippingPromo.value || 0),
|
|
minSubtotal: Number(shippingPromo.minSubtotal || 0),
|
|
maxDiscount: Number(shippingPromo.maxDiscount || 0)
|
|
},
|
|
shippingTiers: Array.isArray(shippingTiers)
|
|
? shippingTiers
|
|
.map(tier => ({
|
|
threshold: Number(tier.threshold || 0),
|
|
mode: tier.mode === 'percentage' || tier.mode === 'flat' ? tier.mode : 'percentage',
|
|
value: Number(tier.value || 0)
|
|
}))
|
|
.filter(tier => tier.threshold >= 0 && tier.value >= 0)
|
|
.sort((a, b) => a.threshold - b.threshold)
|
|
: [],
|
|
surcharges: Array.isArray(surcharges)
|
|
? surcharges
|
|
.map(s => ({
|
|
threshold: Number(s.threshold || 0),
|
|
maxThreshold: typeof s.maxThreshold === 'number' && s.maxThreshold > 0 ? s.maxThreshold : null,
|
|
target: s.target === 'shipping' || s.target === 'order' ? s.target : 'shipping',
|
|
amount: Number(s.amount || 0)
|
|
}))
|
|
.filter(s => s.threshold >= 0 && s.amount >= 0)
|
|
.sort((a, b) => a.threshold - b.threshold)
|
|
: [],
|
|
points: {
|
|
pointsPerDollar: typeof pointsConfig.pointsPerDollar === 'number' ? pointsConfig.pointsPerDollar : null,
|
|
redemptionRate: typeof pointsConfig.redemptionRate === 'number' ? pointsConfig.redemptionRate : null,
|
|
pointDollarValue: typeof pointsConfig.pointDollarValue === 'number'
|
|
? pointsConfig.pointDollarValue
|
|
: DEFAULT_POINT_DOLLAR_VALUE
|
|
}
|
|
};
|
|
|
|
let connection;
|
|
let release;
|
|
|
|
try {
|
|
const dbConn = await getDbConnection();
|
|
connection = dbConn.connection;
|
|
release = dbConn.release;
|
|
|
|
const params = [shipCountry, formatDateForSql(startDt), formatDateForSql(endDt)];
|
|
let promoExistsClause = '';
|
|
if (promoIds.length > 0) {
|
|
const placeholders = promoIds.map(() => '?').join(',');
|
|
promoExistsClause = `
|
|
AND EXISTS (
|
|
SELECT 1 FROM order_discounts od
|
|
WHERE od.order_id = o.order_id
|
|
AND od.discount_active = 1
|
|
AND od.discount_type = 10
|
|
AND od.discount_code IN (${placeholders})
|
|
)
|
|
`;
|
|
params.push(...promoIds);
|
|
}
|
|
|
|
const ordersQuery = `
|
|
SELECT
|
|
o.order_id,
|
|
o.summary_subtotal,
|
|
COALESCE(o.summary_subtotal_retail, o.summary_subtotal) AS summary_subtotal_retail,
|
|
COALESCE(o.summary_discount_subtotal, 0) AS summary_discount_subtotal,
|
|
COALESCE(o.summary_shipping, 0) AS summary_shipping,
|
|
COALESCE(o.summary_shipping_rush, 0) AS summary_shipping_rush,
|
|
COALESCE(o.ship_method_cost, 0) AS ship_method_cost,
|
|
COALESCE(o.summary_points, 0) AS summary_points,
|
|
COALESCE(c.total_cogs, 0) AS total_cogs,
|
|
COALESCE(p.points_redeemed, 0) AS points_redeemed
|
|
FROM _order o
|
|
LEFT JOIN (
|
|
SELECT order_id, SUM(cogs_amount) AS total_cogs
|
|
FROM report_sales_data
|
|
WHERE action IN (1,2,3)
|
|
GROUP BY order_id
|
|
) c ON c.order_id = o.order_id
|
|
LEFT JOIN (
|
|
SELECT order_id, SUM(discount_amount_subtotal) AS points_redeemed
|
|
FROM order_discounts
|
|
WHERE discount_type = 20 AND discount_active = 1
|
|
GROUP BY order_id
|
|
) p ON p.order_id = o.order_id
|
|
WHERE o.summary_total > 0
|
|
AND o.order_status >= 20
|
|
AND o.ship_method_selected <> 'holdit'
|
|
AND o.ship_country = ?
|
|
AND o.date_placed BETWEEN ? AND ?
|
|
${promoExistsClause}
|
|
`;
|
|
|
|
const [orders] = await connection.execute(ordersQuery, params);
|
|
|
|
if (release) {
|
|
release();
|
|
release = null;
|
|
}
|
|
|
|
let totalSubtotal = 0;
|
|
let totalProductDiscount = 0;
|
|
let totalCogs = 0;
|
|
let totalPointsAwarded = 0;
|
|
let totalPointsRedeemedDollars = 0;
|
|
for (const o of orders) {
|
|
totalSubtotal += Number(o.summary_subtotal) || 0;
|
|
totalProductDiscount += Number(o.summary_discount_subtotal) || 0;
|
|
totalCogs += Number(o.total_cogs) || 0;
|
|
totalPointsAwarded += Number(o.summary_points) || 0;
|
|
totalPointsRedeemedDollars += Number(o.points_redeemed) || 0;
|
|
}
|
|
|
|
const productDiscountRate = totalSubtotal > 0 ? totalProductDiscount / totalSubtotal : 0;
|
|
const overallCogsPercentage = totalSubtotal > 0 ? totalCogs / totalSubtotal : 0;
|
|
const pointsPerDollar = config.points.pointsPerDollar != null
|
|
? config.points.pointsPerDollar
|
|
: (totalSubtotal > 0 ? totalPointsAwarded / totalSubtotal : 0);
|
|
const pointDollarValue = config.points.pointDollarValue || DEFAULT_POINT_DOLLAR_VALUE;
|
|
let redemptionRate;
|
|
if (config.points.redemptionRate != null) {
|
|
redemptionRate = config.points.redemptionRate;
|
|
} else if (totalPointsAwarded > 0 && pointDollarValue > 0) {
|
|
const totalRedeemedPoints = totalPointsRedeemedDollars / pointDollarValue;
|
|
redemptionRate = Math.min(1, totalRedeemedPoints / totalPointsAwarded);
|
|
} else {
|
|
redemptionRate = 0;
|
|
}
|
|
|
|
const derived = {
|
|
overallCogsPercentage,
|
|
pointsPerDollar,
|
|
redemptionRate,
|
|
pointDollarValue,
|
|
};
|
|
|
|
const buckets = new Map();
|
|
for (const range of RANGE_DEFINITIONS) {
|
|
buckets.set(range.key, emptyBucketAccumulator(range));
|
|
}
|
|
|
|
let grandTotalProfit = 0;
|
|
let grandTotalRevenue = 0;
|
|
|
|
for (const order of orders) {
|
|
const sim = simulateOrder(order, config, derived);
|
|
const bucketKey = bucketKeyFor(sim.orderValue);
|
|
const bucket = buckets.get(bucketKey);
|
|
accumulate(bucket, sim);
|
|
grandTotalProfit += sim.profit;
|
|
grandTotalRevenue += sim.totalRevenue;
|
|
}
|
|
|
|
const totalOrders = orders.length;
|
|
const bucketResults = RANGE_DEFINITIONS.map((range) =>
|
|
finalizeBucket(buckets.get(range.key), totalOrders)
|
|
);
|
|
|
|
const weightedProfitAmount = totalOrders > 0 ? grandTotalProfit / totalOrders : 0;
|
|
const weightedProfitPercent = grandTotalRevenue > 0 ? grandTotalProfit / grandTotalRevenue : 0;
|
|
|
|
res.json({
|
|
dateRange: {
|
|
start: startDt.toISO(),
|
|
end: endDt.toISO()
|
|
},
|
|
totals: {
|
|
orders: totalOrders,
|
|
subtotal: totalSubtotal,
|
|
productDiscountRate,
|
|
pointsPerDollar,
|
|
redemptionRate,
|
|
pointDollarValue,
|
|
weightedProfitAmount,
|
|
weightedProfitPercent,
|
|
overallCogsPercentage: cogsCalculationMode === 'average' ? overallCogsPercentage : undefined
|
|
},
|
|
buckets: bucketResults
|
|
});
|
|
} catch (error) {
|
|
if (release) {
|
|
try {
|
|
release();
|
|
} catch (releaseError) {
|
|
console.error('Failed to release connection after error:', releaseError);
|
|
}
|
|
} else if (connection) {
|
|
try {
|
|
connection.destroy();
|
|
} catch (destroyError) {
|
|
console.error('Failed to destroy connection after error:', destroyError);
|
|
}
|
|
}
|
|
|
|
console.error('Error running discount simulation:', error);
|
|
res.status(500).json({ error: 'Failed to run discount simulation' });
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|