Per-PDF rates are in minor units (cents) per document. Multipliers are fractions (e.g. 0.15 = + * +15%). Flat/one-time fees are in minor units. + */ +public record PricingRates( + long perPdfMinorUnder1M, + long perPdfMinorUnder5M, + long perPdfMinor5MPlus, + double priorityUplift, + double dedicatedUplift, + double indemnificationUplift, + double[] termDiscountByYear, // index 0 = 1yr … index 4 = 5yr + long qbrAnnualMinor, + long trainingOneTimeMinor) { + + public static PricingRates defaults() { + return new PricingRates( + 5, // $0.05 / PDF under 1M/yr + 4, // $0.04 / PDF at 1M–5M/yr + 3, // $0.03 / PDF at 5M+/yr + 0.15, // priority +15% + 0.30, // dedicated +30% + 0.05, // IP indemnification +5% + new double[] {0.0, 0.05, 0.10, 0.12, 0.15}, + 800_000, // QBRs $8,000 / yr + 750_000); // onboarding & training $7,500 one-time + } + + /** Volume-banded per-PDF rate for an annual volume, in minor units. */ + public long perPdfMinor(long annualVolume) { + if (annualVolume >= 5_000_000) return perPdfMinor5MPlus; + if (annualVolume >= 1_000_000) return perPdfMinorUnder5M; + return perPdfMinorUnder1M; + } + + public double termDiscount(int termYears) { + int idx = Math.max(1, Math.min(termYears, 5)) - 1; + return termDiscountByYear[idx]; + } + + public double serviceLevelUplift(String serviceLevel) { + if ("priority".equalsIgnoreCase(serviceLevel)) return priorityUplift; + if ("dedicated".equalsIgnoreCase(serviceLevel)) return dedicatedUplift; + return 0.0; + } +} diff --git a/app/saas/src/main/java/stirling/software/saas/procurement/pricing/ProcurementPricingService.java b/app/saas/src/main/java/stirling/software/saas/procurement/pricing/ProcurementPricingService.java new file mode 100644 index 0000000000..62d5baed9d --- /dev/null +++ b/app/saas/src/main/java/stirling/software/saas/procurement/pricing/ProcurementPricingService.java @@ -0,0 +1,125 @@ +package stirling.software.saas.procurement.pricing; + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Service; + +/** + * The canonical enterprise pricing engine — the single server-side definition the quote builder, + * the order form, and the Stripe checkout all derive from. A faithful port of the marketing + * prototype's {@code quotePricing}: + * + *
+ * annual = volume x perPdfRate x serviceLevelMult x (indemnification ? 1.05 : 1) + * annualNet = round(annual x (1 - termDiscount)) + qbr + * tcv = annualNet x termYears + training + *+ * + * The multi-year discount applies to usage + service level + indemnification, but NOT to the flat + * QBR fee (added after), and one-time training sits outside the recurring total. All money is in + * minor units (cents). Rates come from {@link PricingRates} (Stripe-backed in prod). + */ +@Service +public class ProcurementPricingService { + + /** Bespoke/committed deals don't price below this ACV; the builder floors against it. */ + public static final long MIN_ACV_MINOR = 5_000_000L; // $50,000 + + /** + * Estimated annual PDF volume from seat count (~2,012.5 PDFs/user/yr = 5 docs/day x 230 working + * days x 1.75), used to prefill the builder's volume step. Rounded, matching the prototype's + * {@code users x 5 x 230 x 1.75}. + */ + public long estimateAnnualVolume(int users) { + return Math.round(Math.max(0, users) * 5.0 * 230.0 * 1.75); + } + + public QuoteBreakdown price(QuoteConfig cfg) { + return price(cfg, PricingRates.defaults()); + } + + public QuoteBreakdown price(QuoteConfig cfg, PricingRates rates) { + // Never trust the client's volume: clamp to non-negative so a tampered request can't drive + // a + // negative amount. The rate card and formula are server-side, so the browser can't lower + // the + // price — only pick a smaller, legitimate config. (See MIN_ACV_MINOR for the committed + // floor, + // a policy decision that is intentionally not force-applied here — see the review notes.) + long volume = Math.max(0, cfg.volume()); + long perPdf = rates.perPdfMinor(volume); + long usage = Math.round(volume * (double) perPdf); // base, pre-service-level + double slaUplift = rates.serviceLevelUplift(cfg.serviceLevel()); + long withSla = Math.round(usage * (1.0 + slaUplift)); + long withIndemnity = + cfg.indemnification() + ? Math.round(withSla * (1.0 + rates.indemnificationUplift())) + : withSla; + + double termDiscount = rates.termDiscount(cfg.termYears()); + long discount = Math.round(withIndemnity * termDiscount); + long qbr = cfg.qbr() ? rates.qbrAnnualMinor() : 0L; + long training = cfg.training() ? rates.trainingOneTimeMinor() : 0L; + + long annualNet = (withIndemnity - discount) + qbr; + long tcv = annualNet * cfg.termYears() + training; + + List