> ## Documentation Index > Fetch the complete documentation index at: https://docs.gorules.io/llms.txt > Use this file to discover all available pages before exploring further. # Dynamic pricing rules > Build pricing rules that adjust based on customer segments, order values, and promotions. export const DecisionGraphViz = ({nodes = [], edges = [], highlighted = null, title = null}) => { const nodeColors = { input: { bg: '#f8fafc', border: '#94a3b8', text: '#475569', icon: '→' }, output: { bg: '#f8fafc', border: '#94a3b8', text: '#475569', icon: '←' }, table: { bg: '#fefce8', border: '#d9c860', text: '#7c6f2a', icon: '▤' }, expression: { bg: '#f5f3ff', border: '#a78bda', text: '#5b4a8c', icon: 'ƒ' }, function: { bg: '#fdf2f8', border: '#e293b7', text: '#8c4a6d', icon: '{ }' }, switch: { bg: '#f0fdfa', border: '#6bc4b8', text: '#3d7a72', icon: '◇' } }; const nodeWidth = 140; const nodeHeight = 64; const horizontalGap = 80; const verticalGap = 24; const inDegree = {}; const outEdges = {}; nodes.forEach(n => { inDegree[n.id] = 0; outEdges[n.id] = []; }); edges.forEach(e => { inDegree[e.to] = (inDegree[e.to] || 0) + 1; outEdges[e.from] = outEdges[e.from] || []; outEdges[e.from].push(e.to); }); const queue = nodes.filter(n => inDegree[n.id] === 0).map(n => n.id); const nodeLevel = {}; queue.forEach(id => nodeLevel[id] = 0); const tempInDegree = { ...inDegree }; while (queue.length > 0) { const current = queue.shift(); const currentLevel = nodeLevel[current]; (outEdges[current] || []).forEach(next => { nodeLevel[next] = Math.max(nodeLevel[next] || 0, currentLevel + 1); tempInDegree[next]--; if (tempInDegree[next] === 0) queue.push(next); }); } const levels = {}; nodes.forEach(n => { const level = nodeLevel[n.id] || 0; levels[level] = levels[level] || []; levels[level].push(n); }); const nodePositions = {}; const numLevels = Object.keys(levels).length; const maxNodesInLevel = Math.max(...Object.values(levels).map(l => l.length), 1); const canvasHeight = Math.max(maxNodesInLevel * (nodeHeight + verticalGap) + 60, 180); const canvasWidth = numLevels * (nodeWidth + horizontalGap) + 80; Object.entries(levels).forEach(([level, levelNodes]) => { const levelNum = parseInt(level); const x = 40 + levelNum * (nodeWidth + horizontalGap); const totalHeight = levelNodes.length * nodeHeight + (levelNodes.length - 1) * verticalGap; const startY = (canvasHeight - totalHeight) / 2; levelNodes.forEach((node, index) => { nodePositions[node.id] = { x, y: startY + index * (nodeHeight + verticalGap) }; }); }); const edgePaths = edges.map((edge, i) => { const from = nodePositions[edge.from]; const to = nodePositions[edge.to]; if (!from || !to) return null; const startX = from.x + nodeWidth; const startY = from.y + nodeHeight / 2; const endX = to.x - 6; const endY = to.y + nodeHeight / 2; const dx = endX - startX; const controlOffset = Math.min(dx * 0.4, 40); return { key: `edge-${i}`, path: `M ${startX} ${startY} C ${startX + controlOffset} ${startY}, ${endX - controlOffset} ${endY}, ${endX} ${endY}` }; }).filter(Boolean); const uniqueId = `graph-${Math.random().toString(36).substring(2, 11)}`; const containerRef = useRef(null); const [scale, setScale] = useState(1); const [position, setPosition] = useState({ x: 0, y: 0 }); const [isDragging, setIsDragging] = useState(false); const [dragStart, setDragStart] = useState({ x: 0, y: 0 }); const handleWheel = e => { e.preventDefault(); const delta = e.deltaY > 0 ? -0.1 : 0.1; setScale(s => Math.max(0.4, Math.min(2, s + delta))); }; const handleMouseDown = e => { if (e.target.closest('button')) return; setIsDragging(true); setDragStart({ x: e.clientX - position.x, y: e.clientY - position.y }); }; const handleMouseMove = e => { if (!isDragging) return; setPosition({ x: e.clientX - dragStart.x, y: e.clientY - dragStart.y }); }; const handleMouseUp = () => setIsDragging(false); const handleFit = () => { const container = containerRef.current; if (container) { const containerWidth = container.clientWidth - 40; const containerHeight = container.clientHeight - 80; const scaleX = containerWidth / canvasWidth; const scaleY = containerHeight / canvasHeight; const fitScale = Math.min(scaleX, scaleY, 1); setScale(Math.max(0.4, fitScale)); } else { setScale(1); } setPosition({ x: 0, y: 0 }); }; const handleZoomIn = () => setScale(s => Math.min(s + 0.15, 2)); const handleZoomOut = () => setScale(s => Math.max(s - 0.15, 0.4)); useEffect(() => { const container = containerRef.current; if (container) { container.addEventListener('wheel', handleWheel, { passive: false }); return () => container.removeEventListener('wheel', handleWheel); } }, []); useEffect(() => { const timer = setTimeout(() => { const container = containerRef.current; if (container) { const containerWidth = container.clientWidth - 40; const containerHeight = container.clientHeight - 80; const scaleX = containerWidth / canvasWidth; const scaleY = containerHeight / canvasHeight; const fitScale = Math.min(scaleX, scaleY, 1); setScale(Math.max(0.4, fitScale)); } }, 0); return () => clearTimeout(timer); }, [canvasWidth, canvasHeight]); const containerHeight = Math.max(300, Math.min(canvasHeight + 80, 420)); return
{title &&
{title}
}
{}
{}
{} {edgePaths.map(edge => )} {} {nodes.map(node => { const pos = nodePositions[node.id]; if (!pos) return null; const colors = nodeColors[node.type] || nodeColors.expression; const isHighlighted = highlighted === node.id; return
{colors.icon}
{node.label}
; })}
{}
{Object.entries(nodeColors).map(([type, colors]) =>
{colors.icon}
{type}
)}
; }; export const ExpressionViz = ({entries = []}) => { const allCells = entries.flatMap((entry, i) => [
{entry.key}
,
{entry.value}
]); return
{allCells}
; }; export const DecisionTableViz = ({inputs = [], outputs = [], rows = []}) => { const colCount = inputs.length + outputs.length; const getFieldDisplay = field => !field || field === '-' ? '-' : field; const allCells = rows.flatMap((row, ri) => [...inputs.map((input, i) =>
{row[input.field] ?? ''}
), ...outputs.map((output, i) =>
{row[output.field] ?? ''}
)]); return
{}
Inputs
Outputs
{} {inputs.map((input, i) =>
{input.name}
{getFieldDisplay(input.field)}
)} {outputs.map((output, i) =>
{output.name}
{getFieldDisplay(output.field)}
)} {} {allCells}
; }; This guide walks through building a dynamic pricing system that calculates discounts, applies promotions, and determines final prices based on customer and order data. ## What you'll build A pricing decision that: * Applies tiered discounts based on customer loyalty level * Adds volume discounts for large orders * Stacks promotional codes * Calculates final price with all adjustments Want to skip ahead? Download the completed decision and import it directly. ### Decision flow ## Example input ```json theme={null} { "customer": { "tier": "gold", "yearsActive": 3 }, "order": { "subtotal": 450, "itemCount": 12 }, "promoCode": "SUMMER20" } ``` ## Step 1: Customer tier discounts Create a decision table for base discounts by customer tier: = 3", discount: "0.15" }, { "customer.tier": '"gold"', "customer.yearsActive": "< 3", discount: "0.12" }, { "customer.tier": '"silver"', "customer.yearsActive": ">= 2", discount: "0.10" }, { "customer.tier": '"silver"', "customer.yearsActive": "< 2", discount: "0.08" }, { "customer.tier": "", "customer.yearsActive": "", discount: "0.05" } ]} /> **Logic:** * Platinum customers always get 20% * Gold customers get 15% after 3 years, 12% before * Silver customers get 10% after 2 years, 8% before * Everyone else gets 5% ## Step 2: Volume discounts Add another decision table for quantity-based discounts: = 50", volumeDiscount: "0.10" }, { "order.itemCount": ">= 25", volumeDiscount: "0.07" }, { "order.itemCount": ">= 10", volumeDiscount: "0.05" }, { "order.itemCount": "", volumeDiscount: "0" } ]} /> ## Step 3: Promotional codes Handle promo codes with another table: = 100", promoDiscount: "0.20", promoType: '"percentage"' }, { promoCode: '"FLAT50"', "order.subtotal": ">= 200", promoDiscount: "50", promoType: '"fixed"' }, { promoCode: '"NEWUSER"', "order.subtotal": "", promoDiscount: "0.15", promoType: '"percentage"' }, { promoCode: "", "order.subtotal": "", promoDiscount: "0", promoType: '"none"' } ]} /> ## Step 4: Calculate final price Use an expression node to combine all discounts: **Key logic:** * Calculate savings from each discount type * Cap total discount at 40% to protect margins * Round to 2 decimal places ## Testing scenarios | Scenario | Expected result | | ------------------------------------------- | ------------------------------ | | Gold customer, 3+ years, 12 items, no promo | 15% tier + 5% volume = 20% off | | New customer, 5 items, NEWUSER code | 5% tier + 15% promo = 20% off | | Platinum, 50 items, SUMMER20 | Capped at 40% (would be 50%) | ## Output structure ```json theme={null} { "baseAmount": 450, "tierSavings": 67.50, "volumeSavings": 22.50, "promoSavings": 90, "totalDiscount": 180, "finalPrice": 270 } ``` ## Variations ### Time-based pricing Add date conditions for seasonal pricing: ### Geographic pricing Adjust by region: