@managesome/eposmatic-toolkit 0.2.719 → 0.2.720
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/helpers/types/order-engine.d.ts +12 -0
- package/lib/helpers/utils/halfhalf-setup-helpers.js +23 -3
- package/lib/helpers/utils/order-engine.d.ts +24 -17
- package/lib/helpers/utils/order-engine.js +56 -22
- package/lib/tests/nested-halfhalf-segment-price.test.js +37 -0
- package/lib/tests/specials-halfhalf-pricing.test.js +140 -0
- package/package.json +1 -1
|
@@ -5,6 +5,18 @@ export interface IOrderEngineOption extends Omit<IModifierOption, 'modifiers' |
|
|
|
5
5
|
loyalty_applied: boolean;
|
|
6
6
|
voucher_applied: boolean;
|
|
7
7
|
price: number;
|
|
8
|
+
/**
|
|
9
|
+
* The price the engine assigned to this option when the item was built
|
|
10
|
+
* (the catalog/definition value — NOT a persisted order value). It is the
|
|
11
|
+
* engine's own memory for reversible price normalization such as
|
|
12
|
+
* `choose_expensive_segment_price`: normalizing re-bases each option from
|
|
13
|
+
* here first, so the rule can raise AND lower across selection changes
|
|
14
|
+
* without any caller having to keep a pristine copy of the item.
|
|
15
|
+
*
|
|
16
|
+
* Optionally absent (e.g. hand-built engine items): callers that normalize
|
|
17
|
+
* prices should then pass an explicit `basePrices` map instead.
|
|
18
|
+
*/
|
|
19
|
+
base_price?: number;
|
|
8
20
|
quantity: number;
|
|
9
21
|
modifiers: IOrderEngineModifier[];
|
|
10
22
|
}
|
|
@@ -539,13 +539,29 @@ function convertHalfHalfToOrderItem({ halfHalfItem, selectedHalfHalfItems, quant
|
|
|
539
539
|
*/
|
|
540
540
|
function convertHalfHalfToOrderEngineItem({ halfHalfItem, selectedHalfHalfItems, quantity, platform, existingOrderItem, orderItemId, chooseExpensiveSegmentPrice, }) {
|
|
541
541
|
let menu_id;
|
|
542
|
-
|
|
542
|
+
/**
|
|
543
|
+
* Definition prices of the SEGMENT ITEM (its own price + nested modifier
|
|
544
|
+
* option prices). The selected per-segment order items can carry prices
|
|
545
|
+
* raised by a previous `choose_expensive_segment_price` normalization (edit
|
|
546
|
+
* flow, de-structured line), so the engine stamps THIS baseline as its own
|
|
547
|
+
* memory `base_price` — re-apply can then raise AND lower.
|
|
548
|
+
*/
|
|
549
|
+
const getSegmentItemBasePrices = (itemId) => {
|
|
550
|
+
const workableItem = halfHalfItem.items.find((item) => item._id === itemId);
|
|
551
|
+
return workableItem == null ? {} : (0, order_engine_1.getOptionPriceMapFromItem)(workableItem, platform);
|
|
552
|
+
};
|
|
553
|
+
const getWorkableItemPrice = (itemId) => {
|
|
554
|
+
const workableItem = halfHalfItem.items.find((item) => item._id === itemId);
|
|
555
|
+
return workableItem == null ? undefined : (0, platform_catalog_1.getPriceEnum)(workableItem.price, platform);
|
|
556
|
+
};
|
|
557
|
+
const toEngineModifiers = (modifiers, depth, basePrices) => (modifiers ?? []).map((modifier) => {
|
|
543
558
|
const options = modifier.options ?? [];
|
|
544
559
|
const engineOptions = options.map((option) => ({
|
|
545
560
|
_id: option._id,
|
|
546
561
|
ref: option.ref,
|
|
547
562
|
name: option.name,
|
|
548
563
|
price: option.price,
|
|
564
|
+
base_price: basePrices[option._id] ?? option.price,
|
|
549
565
|
quantity: option.quantity || 1,
|
|
550
566
|
is_free: option.is_free ?? false,
|
|
551
567
|
default: true,
|
|
@@ -555,7 +571,7 @@ function convertHalfHalfToOrderEngineItem({ halfHalfItem, selectedHalfHalfItems,
|
|
|
555
571
|
sold_out: [],
|
|
556
572
|
sort_id: 0,
|
|
557
573
|
excluded_platforms: [],
|
|
558
|
-
modifiers: toEngineModifiers(option.modifiers, depth + 1),
|
|
574
|
+
modifiers: toEngineModifiers(option.modifiers, depth + 1, basePrices),
|
|
559
575
|
}));
|
|
560
576
|
return {
|
|
561
577
|
_id: modifier._id,
|
|
@@ -581,12 +597,16 @@ function convertHalfHalfToOrderEngineItem({ halfHalfItem, selectedHalfHalfItems,
|
|
|
581
597
|
menu_id = selectedItem.menu_id;
|
|
582
598
|
}
|
|
583
599
|
const segment = halfHalfItem.segments[s];
|
|
600
|
+
const segmentBasePrices = getSegmentItemBasePrices(selectedItem.item_id);
|
|
584
601
|
const segmentOptions = [
|
|
585
602
|
{
|
|
586
603
|
_id: selectedItem.item_id,
|
|
587
604
|
ref: selectedItem.item_id,
|
|
588
605
|
name: selectedItem.name,
|
|
589
606
|
price: selectedItem.price,
|
|
607
|
+
// Definition price, not the (possibly previously raised) selected
|
|
608
|
+
// order item price — see `getSegmentItemBasePrices`.
|
|
609
|
+
base_price: getWorkableItemPrice(selectedItem.item_id) ?? selectedItem.price,
|
|
590
610
|
quantity: selectedItem.quantity || 1,
|
|
591
611
|
is_free: false,
|
|
592
612
|
default: true,
|
|
@@ -596,7 +616,7 @@ function convertHalfHalfToOrderEngineItem({ halfHalfItem, selectedHalfHalfItems,
|
|
|
596
616
|
sold_out: [],
|
|
597
617
|
sort_id: 0,
|
|
598
618
|
excluded_platforms: [],
|
|
599
|
-
modifiers: toEngineModifiers(selectedItem.modifiers, 1),
|
|
619
|
+
modifiers: toEngineModifiers(selectedItem.modifiers, 1, segmentBasePrices),
|
|
600
620
|
},
|
|
601
621
|
];
|
|
602
622
|
const segmentModifier = {
|
|
@@ -7,11 +7,15 @@ export declare function syncOrderEngineItem(orderEngineItem: IOrderEngineItem):
|
|
|
7
7
|
export declare function checkIfModifiersExist(modifiers: IModifier[] | null, platform: PLATFORMS_ENUM | undefined): boolean;
|
|
8
8
|
export declare function makeSpaceForFreeOptions(options: IOrderEngineOption[], num_free_options: number | null | undefined): IOrderEngineOption[];
|
|
9
9
|
/**
|
|
10
|
-
*
|
|
11
|
-
*
|
|
12
|
-
*
|
|
13
|
-
*
|
|
14
|
-
*
|
|
10
|
+
* OPTIONAL override of the pristine-price baseline for
|
|
11
|
+
* `choose_expensive_segment_price`.
|
|
12
|
+
*
|
|
13
|
+
* The engine normally re-bases itself from the `base_price` stamped on every
|
|
14
|
+
* option when the item was built (its own memory — see `IOrderEngineOption`),
|
|
15
|
+
* so re-applying the rule after a selection change can LOWER prices again and
|
|
16
|
+
* callers never have to keep a pristine copy of the item. Pass `basePrices`
|
|
17
|
+
* only when the baseline must come from somewhere else (e.g. a pre-computed
|
|
18
|
+
* `_id -> price` map); it takes precedence over the stamps.
|
|
15
19
|
*/
|
|
16
20
|
export interface IChooseExpensiveSegmentPriceOptions {
|
|
17
21
|
basePrices?: Record<string, number>;
|
|
@@ -25,10 +29,11 @@ export interface IChooseExpensiveSegmentPriceOptions {
|
|
|
25
29
|
* half the user actually picked sets the charged price for every picked half
|
|
26
30
|
* (cheaper halves are raised to it; picking a cheaper combination later
|
|
27
31
|
* lowers them again). It cannot run during `IHalfHalfSetup -> IItem`
|
|
28
|
-
* conversion — it runs at display/submit time on
|
|
29
|
-
*
|
|
30
|
-
* the result
|
|
31
|
-
*
|
|
32
|
+
* conversion — it runs at display/submit time on the engine item, re-basing
|
|
33
|
+
* every price from the engine's own memory (the `base_price` stamped at
|
|
34
|
+
* conversion) so the result NEVER accumulates raises, even when the item is
|
|
35
|
+
* mutated in place across selection changes. `basePrices` can override that
|
|
36
|
+
* baseline (see `IChooseExpensiveSegmentPriceOptions`).
|
|
32
37
|
*
|
|
33
38
|
* Rule: `price = base + upsell` — the item (option) level upsell is already
|
|
34
39
|
* baked into the option price at conversion. choose_expensive compares every
|
|
@@ -87,19 +92,21 @@ export declare function getOptionPriceMapFromItem(item: IItem | ISimplifiedCatal
|
|
|
87
92
|
nestedHalfHalfSegmentsOnly?: boolean;
|
|
88
93
|
}): Record<string, number>;
|
|
89
94
|
/**
|
|
90
|
-
*
|
|
91
|
-
*
|
|
95
|
+
* Re-bases every engine option price from the engine's own memory (the
|
|
96
|
+
* `base_price` stamped at conversion), optionally overridden by an explicit
|
|
97
|
+
* `basePrices` map. Called when a drawer builds the engine item so state
|
|
92
98
|
* (sidebar prices, edit baselines) never carries a previous normalization.
|
|
93
99
|
*
|
|
94
100
|
* `options.nestedHalfHalfOnly` restricts the reset to the subtrees of
|
|
95
101
|
* HALF_HALF options — the exact scope `getOptionPriceMapFromItem` builds when
|
|
96
|
-
* called with `nestedHalfHalfSegmentsOnly`.
|
|
97
|
-
*
|
|
98
|
-
* so a blanket reset with the scoped map would push the
|
|
99
|
-
* the top-level option.
|
|
100
|
-
* this
|
|
102
|
+
* called with `nestedHalfHalfSegmentsOnly`. Only needed when an external
|
|
103
|
+
* `basePrices` map is passed (a special's top-level options reuse their `_id`s
|
|
104
|
+
* at different prices, so a blanket reset with the scoped map would push the
|
|
105
|
+
* segment share onto the top-level option). With the engine's own stamps the
|
|
106
|
+
* scope is inherent — pass the SAME scope to the map builder and to this
|
|
107
|
+
* reset when you do pass a map.
|
|
101
108
|
*/
|
|
102
|
-
export declare function resetOrderEngineItemPrices(orderEngineItem: IOrderEngineItem, basePrices
|
|
109
|
+
export declare function resetOrderEngineItemPrices(orderEngineItem: IOrderEngineItem, basePrices?: Record<string, number>, options?: {
|
|
103
110
|
nestedHalfHalfOnly?: boolean;
|
|
104
111
|
}): IOrderEngineItem;
|
|
105
112
|
export type IOrderEngineItemRewardClaim = {
|
|
@@ -287,13 +287,17 @@ function makeSpaceForFreeOptions(options, num_free_options) {
|
|
|
287
287
|
}
|
|
288
288
|
return [...defaultPriceOptions, ...nonDefaultOptions].sort((a, b) => a.sort_id - b.sort_id);
|
|
289
289
|
}
|
|
290
|
-
/**
|
|
290
|
+
/**
|
|
291
|
+
* Restores engine option prices from the pristine baseline: the per-option
|
|
292
|
+
* `base_price` the engine stamped when the item was built, overridden by the
|
|
293
|
+
* optional external `_id -> price` map (see
|
|
294
|
+
* `IChooseExpensiveSegmentPriceOptions`). This is the engine's own memory —
|
|
295
|
+
* re-basing never depends on callers keeping a pristine copy of the item.
|
|
296
|
+
*/
|
|
291
297
|
const resetEngineOptionPrices = (modifiers, basePrices) => {
|
|
292
|
-
if (basePrices == null)
|
|
293
|
-
return modifiers;
|
|
294
298
|
const resetOption = (option) => ({
|
|
295
299
|
...option,
|
|
296
|
-
price: basePrices[option._id] ?? option.price,
|
|
300
|
+
price: basePrices?.[option._id] ?? option.base_price ?? option.price,
|
|
297
301
|
modifiers: (option.modifiers ?? []).map((modifier) => ({
|
|
298
302
|
...modifier,
|
|
299
303
|
options: (modifier.options ?? []).map(resetOption),
|
|
@@ -304,6 +308,24 @@ const resetEngineOptionPrices = (modifiers, basePrices) => {
|
|
|
304
308
|
options: (modifier.options ?? []).map(resetOption),
|
|
305
309
|
}));
|
|
306
310
|
};
|
|
311
|
+
/** True when two modifier trees carry the same option prices at the same positions. */
|
|
312
|
+
const haveSameOptionPrices = (a, b) => {
|
|
313
|
+
if (a.length !== b.length)
|
|
314
|
+
return false;
|
|
315
|
+
for (let i = 0; i < a.length; i++) {
|
|
316
|
+
const optionsA = a[i].options ?? [];
|
|
317
|
+
const optionsB = b[i].options ?? [];
|
|
318
|
+
if (optionsA.length !== optionsB.length)
|
|
319
|
+
return false;
|
|
320
|
+
for (let j = 0; j < optionsA.length; j++) {
|
|
321
|
+
if ((optionsA[j].price ?? 0) !== (optionsB[j].price ?? 0))
|
|
322
|
+
return false;
|
|
323
|
+
if (!haveSameOptionPrices(optionsA[j].modifiers ?? [], optionsB[j].modifiers ?? []))
|
|
324
|
+
return false;
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
return true;
|
|
328
|
+
};
|
|
307
329
|
/**
|
|
308
330
|
* Applies `choose_expensive_segment_price` to an order engine item converted
|
|
309
331
|
* from a half-half setup (top-level modifier groups = segments, single-select
|
|
@@ -313,10 +335,11 @@ const resetEngineOptionPrices = (modifiers, basePrices) => {
|
|
|
313
335
|
* half the user actually picked sets the charged price for every picked half
|
|
314
336
|
* (cheaper halves are raised to it; picking a cheaper combination later
|
|
315
337
|
* lowers them again). It cannot run during `IHalfHalfSetup -> IItem`
|
|
316
|
-
* conversion — it runs at display/submit time on
|
|
317
|
-
*
|
|
318
|
-
* the result
|
|
319
|
-
*
|
|
338
|
+
* conversion — it runs at display/submit time on the engine item, re-basing
|
|
339
|
+
* every price from the engine's own memory (the `base_price` stamped at
|
|
340
|
+
* conversion) so the result NEVER accumulates raises, even when the item is
|
|
341
|
+
* mutated in place across selection changes. `basePrices` can override that
|
|
342
|
+
* baseline (see `IChooseExpensiveSegmentPriceOptions`).
|
|
320
343
|
*
|
|
321
344
|
* Rule: `price = base + upsell` — the item (option) level upsell is already
|
|
322
345
|
* baked into the option price at conversion. choose_expensive compares every
|
|
@@ -357,7 +380,9 @@ function applyChooseExpensiveSegmentPrice(orderEngineItem, options) {
|
|
|
357
380
|
* segment), otherwise the raised segment groups.
|
|
358
381
|
*/
|
|
359
382
|
function applyChooseExpensiveSegmentPriceToModifiers(segmentGroups, options) {
|
|
360
|
-
|
|
383
|
+
// Re-base from the engine's own memory (or the caller's override) so the
|
|
384
|
+
// rule is always a pure function of the CURRENT selection: switching to a
|
|
385
|
+
// cheaper combination lowers the previously raised halves again.
|
|
361
386
|
const groups = resetEngineOptionPrices(segmentGroups, options?.basePrices);
|
|
362
387
|
// Prices of ALL options of required (price-defining) modifier groups, at
|
|
363
388
|
// any depth — e.g. "Pizza Size" -> "Large 13"" is part of the item's price
|
|
@@ -394,7 +419,7 @@ function applyChooseExpensiveSegmentPriceToModifiers(segmentGroups, options) {
|
|
|
394
419
|
}
|
|
395
420
|
}
|
|
396
421
|
if (selections.length === 0)
|
|
397
|
-
return
|
|
422
|
+
return haveSameOptionPrices(groups, segmentGroups) ? null : groups;
|
|
398
423
|
// Max over the SELECTED halves only — the "expensive segment" is the most
|
|
399
424
|
// expensive half the user actually picked, not the most expensive option in
|
|
400
425
|
// the setup (otherwise picking A+B would charge as if C+D were chosen).
|
|
@@ -408,7 +433,7 @@ function applyChooseExpensiveSegmentPriceToModifiers(segmentGroups, options) {
|
|
|
408
433
|
}
|
|
409
434
|
}
|
|
410
435
|
if (maxSegmentValue <= 0)
|
|
411
|
-
return
|
|
436
|
+
return haveSameOptionPrices(groups, segmentGroups) ? null : groups;
|
|
412
437
|
// RULE for where the raise lands: on the FIRST PRICED element along the
|
|
413
438
|
// segment's price chain —
|
|
414
439
|
// 1. the segment option's own price (the item base) when it is non-zero
|
|
@@ -448,7 +473,7 @@ function applyChooseExpensiveSegmentPriceToModifiers(segmentGroups, options) {
|
|
|
448
473
|
})),
|
|
449
474
|
};
|
|
450
475
|
};
|
|
451
|
-
|
|
476
|
+
const raised = groups.map((modifier, g) => {
|
|
452
477
|
const options = (modifier.options ?? []).map((option, o) => {
|
|
453
478
|
const selection = selections.find((s) => s.groupIndex === g && s.optionIndex === o);
|
|
454
479
|
if (selection == null)
|
|
@@ -465,6 +490,9 @@ function applyChooseExpensiveSegmentPriceToModifiers(segmentGroups, options) {
|
|
|
465
490
|
});
|
|
466
491
|
return { ...modifier, options };
|
|
467
492
|
});
|
|
493
|
+
// Nothing to change (pristine prices for the current selection): report
|
|
494
|
+
// "no change" so callers keep the original engine item object.
|
|
495
|
+
return haveSameOptionPrices(raised, segmentGroups) ? null : raised;
|
|
468
496
|
}
|
|
469
497
|
/**
|
|
470
498
|
* True when the item has a top-level modifier group option that is a nested
|
|
@@ -539,17 +567,19 @@ function getOptionPriceMapFromItem(item, platform, options) {
|
|
|
539
567
|
return priceMap;
|
|
540
568
|
}
|
|
541
569
|
/**
|
|
542
|
-
*
|
|
543
|
-
*
|
|
570
|
+
* Re-bases every engine option price from the engine's own memory (the
|
|
571
|
+
* `base_price` stamped at conversion), optionally overridden by an explicit
|
|
572
|
+
* `basePrices` map. Called when a drawer builds the engine item so state
|
|
544
573
|
* (sidebar prices, edit baselines) never carries a previous normalization.
|
|
545
574
|
*
|
|
546
575
|
* `options.nestedHalfHalfOnly` restricts the reset to the subtrees of
|
|
547
576
|
* HALF_HALF options — the exact scope `getOptionPriceMapFromItem` builds when
|
|
548
|
-
* called with `nestedHalfHalfSegmentsOnly`.
|
|
549
|
-
*
|
|
550
|
-
* so a blanket reset with the scoped map would push the
|
|
551
|
-
* the top-level option.
|
|
552
|
-
* this
|
|
577
|
+
* called with `nestedHalfHalfSegmentsOnly`. Only needed when an external
|
|
578
|
+
* `basePrices` map is passed (a special's top-level options reuse their `_id`s
|
|
579
|
+
* at different prices, so a blanket reset with the scoped map would push the
|
|
580
|
+
* segment share onto the top-level option). With the engine's own stamps the
|
|
581
|
+
* scope is inherent — pass the SAME scope to the map builder and to this
|
|
582
|
+
* reset when you do pass a map.
|
|
553
583
|
*/
|
|
554
584
|
function resetOrderEngineItemPrices(orderEngineItem, basePrices, options) {
|
|
555
585
|
if (options?.nestedHalfHalfOnly === true) {
|
|
@@ -650,13 +680,17 @@ function convertCatalogItemModifierToOrderEngineItemModifier({ modifiers, orderI
|
|
|
650
680
|
depth: depth + 1,
|
|
651
681
|
});
|
|
652
682
|
// If zeroPriceRefs is present then we set the price to 0
|
|
653
|
-
const
|
|
654
|
-
|
|
655
|
-
|
|
683
|
+
const isZeroPricedOption = zeroPriceRefs != null && (zeroPriceRefs.includes(option.ref) || zeroPriceRefs.includes(modifier.ref));
|
|
684
|
+
const optionPrice = isZeroPricedOption ? 0 : price;
|
|
685
|
+
// The engine's own memory records the CATALOG value (`price` above may
|
|
686
|
+
// come from the persisted order item in edit flows) so re-basing never
|
|
687
|
+
// inherits a previously normalized (raised) price.
|
|
688
|
+
const basePrice = isZeroPricedOption ? 0 : (0, platform_catalog_1.getPriceEnum)(option.price, platform);
|
|
656
689
|
const orderEngineSingleOption = {
|
|
657
690
|
...option,
|
|
658
691
|
default: isDefaultOption,
|
|
659
692
|
price: optionPrice,
|
|
693
|
+
base_price: basePrice,
|
|
660
694
|
quantity: qty,
|
|
661
695
|
modifiers: newModifiers,
|
|
662
696
|
is_free,
|
|
@@ -294,6 +294,18 @@ describe('applyNestedChooseExpensiveSegmentPrice — selected-halves max', () =>
|
|
|
294
294
|
const option = halfHalfOption(item).modifiers.find((m) => m._id === segmentId);
|
|
295
295
|
return option.options.find((o) => o._id === optionId).price;
|
|
296
296
|
}
|
|
297
|
+
/** Stamps `base_price = price` on every option (simulates an engine-built item). */
|
|
298
|
+
function withStampedBasePrices(item) {
|
|
299
|
+
const stampModifier = (modifier) => ({
|
|
300
|
+
...modifier,
|
|
301
|
+
options: modifier.options.map((option) => ({
|
|
302
|
+
...option,
|
|
303
|
+
base_price: option.price,
|
|
304
|
+
modifiers: option.modifiers.map(stampModifier),
|
|
305
|
+
})),
|
|
306
|
+
});
|
|
307
|
+
return { ...item, modifiers: item.modifiers.map(stampModifier) };
|
|
308
|
+
}
|
|
297
309
|
it('a cheap selected pair is NOT raised (max of the SELECTED halves only)', () => {
|
|
298
310
|
// seg-1: milan(500) selected, torent(600) not; seg-2: milan2(500) selected,
|
|
299
311
|
// torent2(600) not.
|
|
@@ -411,4 +423,29 @@ describe('applyNestedChooseExpensiveSegmentPrice — selected-halves max', () =>
|
|
|
411
423
|
expect(segmentPrice(result, 'seg-1', 'milan')).toBe(500);
|
|
412
424
|
expect(segmentPrice(result, 'seg-2', 'torent2')).toBe(600);
|
|
413
425
|
});
|
|
426
|
+
it('re-bases from its own base_price memory when no map is passed (in-place changes)', () => {
|
|
427
|
+
// Engine-built item: every option carries its definition price as memory.
|
|
428
|
+
const built = withStampedBasePrices(withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan', 'seg-2': 'torent2' }));
|
|
429
|
+
const raised = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(built);
|
|
430
|
+
expect(segmentPrice(raised, 'seg-1', 'milan')).toBe(600);
|
|
431
|
+
// Switching to the cheap pair on the RAISED item, without any external
|
|
432
|
+
// map: the previously raised half goes back to its own 500.
|
|
433
|
+
const switched = withSelections(raised, { 'seg-1': 'milan', 'seg-2': 'milan2' });
|
|
434
|
+
const lowered = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched);
|
|
435
|
+
expect(segmentPrice(lowered, 'seg-1', 'milan')).toBe(500);
|
|
436
|
+
expect(segmentPrice(lowered, 'seg-2', 'milan2')).toBe(500);
|
|
437
|
+
// Re-applying without a change is stable.
|
|
438
|
+
expect((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(lowered)).toEqual(lowered);
|
|
439
|
+
});
|
|
440
|
+
it('without stamps and without a map the rule can only raise (legacy behavior)', () => {
|
|
441
|
+
// Hand-built item (no engine memory): the current price is all it knows.
|
|
442
|
+
const raised = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan', 'seg-2': 'torent2' }));
|
|
443
|
+
expect(segmentPrice(raised, 'seg-1', 'milan')).toBe(600);
|
|
444
|
+
const switched = withSelections(raised, { 'seg-1': 'milan', 'seg-2': 'milan2' });
|
|
445
|
+
const still = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched);
|
|
446
|
+
// No memory -> the stale 600 is treated as milan's own price, so the cheap
|
|
447
|
+
// pair is NOT lowered — milan2 is even raised to it (legacy limitation).
|
|
448
|
+
expect(segmentPrice(still, 'seg-1', 'milan')).toBe(600);
|
|
449
|
+
expect(segmentPrice(still, 'seg-2', 'milan2')).toBe(600);
|
|
450
|
+
});
|
|
414
451
|
});
|
|
@@ -1077,6 +1077,26 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
1077
1077
|
const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, { basePrices });
|
|
1078
1078
|
expect(twice).toEqual(once);
|
|
1079
1079
|
});
|
|
1080
|
+
it('engine memory: nested raises are reversible in place, top-level prices untouched', () => {
|
|
1081
|
+
// No external maps at all — the engine re-bases from its own stamps.
|
|
1082
|
+
let engine = selectNested(buildEngine(), ['milan', 'torent']);
|
|
1083
|
+
engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
|
|
1084
|
+
expect(nestedPrice(engine, 0, 'milan')).toBe(100);
|
|
1085
|
+
expect(nestedPrice(engine, 1, 'torent')).toBe(100);
|
|
1086
|
+
// Stamps are per tree position: the nested segment share (100/0) never
|
|
1087
|
+
// collides with the special's own top-level option price (200).
|
|
1088
|
+
expect(nestedHalfHalf(engine).modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(100);
|
|
1089
|
+
expect(engine.modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(200);
|
|
1090
|
+
// The user changes the second half to milan on the RAISED engine.
|
|
1091
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_milan', true);
|
|
1092
|
+
engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
|
|
1093
|
+
// Artificially upgraded milan is back to its own price; de-selected torent
|
|
1094
|
+
// keeps its own; the top-level option is never touched.
|
|
1095
|
+
expect(nestedPrice(engine, 0, 'milan')).toBe(0);
|
|
1096
|
+
expect(nestedPrice(engine, 1, 'milan')).toBe(0);
|
|
1097
|
+
expect(nestedPrice(engine, 0, 'torent')).toBe(100);
|
|
1098
|
+
expect(topLevelPrice(engine, 'torent')).toBe(200);
|
|
1099
|
+
});
|
|
1080
1100
|
it('edit flow: a persisted nested raise is re-based before the next change', () => {
|
|
1081
1101
|
const specialItem = buildSpecialItem();
|
|
1082
1102
|
const basePrices = nestedBasePrices(specialItem);
|
|
@@ -1409,3 +1429,123 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
|
|
|
1409
1429
|
}
|
|
1410
1430
|
});
|
|
1411
1431
|
});
|
|
1432
|
+
// ============================================================================
|
|
1433
|
+
// 6) Engine memory — `base_price` (reversible normalization without maps)
|
|
1434
|
+
// ============================================================================
|
|
1435
|
+
describe('engine memory: base_price makes choose_expensive reversible in place', () => {
|
|
1436
|
+
const itemsMap = {
|
|
1437
|
+
a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
|
|
1438
|
+
b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
|
|
1439
|
+
c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
|
|
1440
|
+
d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
|
|
1441
|
+
};
|
|
1442
|
+
const setup = () => makeHalfHalfSetup({
|
|
1443
|
+
upsell_price: null,
|
|
1444
|
+
items: [
|
|
1445
|
+
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
1446
|
+
{ item_id: 'b', sort_id: 2, upsell_price: null },
|
|
1447
|
+
{ item_id: 'c', sort_id: 3, upsell_price: null },
|
|
1448
|
+
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1449
|
+
],
|
|
1450
|
+
});
|
|
1451
|
+
function buildEngine() {
|
|
1452
|
+
const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
|
|
1453
|
+
return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1454
|
+
item: converted,
|
|
1455
|
+
orderItem: undefined,
|
|
1456
|
+
platform: PLATFORM,
|
|
1457
|
+
tenantId: TENANT_ID,
|
|
1458
|
+
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
1459
|
+
defaultMenuId: null,
|
|
1460
|
+
soldoutModifiers: [],
|
|
1461
|
+
});
|
|
1462
|
+
}
|
|
1463
|
+
function priceOf(engine, segmentId, optionId, base = false) {
|
|
1464
|
+
const option = engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId);
|
|
1465
|
+
return base ? option.base_price : option.price;
|
|
1466
|
+
}
|
|
1467
|
+
it('conversion stamps the catalog definition on every option', () => {
|
|
1468
|
+
const engine = buildEngine();
|
|
1469
|
+
const expected = [
|
|
1470
|
+
['a', 500],
|
|
1471
|
+
['b', 500],
|
|
1472
|
+
['c', 600],
|
|
1473
|
+
['d', 600],
|
|
1474
|
+
];
|
|
1475
|
+
for (const [optionId, value] of expected) {
|
|
1476
|
+
expect(priceOf(engine, 'seg-1', optionId, true)).toBe(value);
|
|
1477
|
+
expect(priceOf(engine, 'seg-1', optionId)).toBe(value);
|
|
1478
|
+
expect(priceOf(engine, 'seg-2', optionId, true)).toBe(value);
|
|
1479
|
+
}
|
|
1480
|
+
});
|
|
1481
|
+
it('changing the choice on the SAME (raised) engine lowers again — no external map', () => {
|
|
1482
|
+
let engine = buildEngine();
|
|
1483
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1484
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1485
|
+
// B+C -> B raised to 600.
|
|
1486
|
+
engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
1487
|
+
expect(priceOf(engine, 'seg-1', 'b')).toBe(600);
|
|
1488
|
+
expect(priceOf(engine, 'seg-2', 'c')).toBe(600);
|
|
1489
|
+
// User changes to A+B on the raised engine: B must come back to its 500.
|
|
1490
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
|
|
1491
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
|
|
1492
|
+
engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
1493
|
+
expect(priceOf(engine, 'seg-1', 'a')).toBe(500);
|
|
1494
|
+
expect(priceOf(engine, 'seg-1', 'b')).toBe(500);
|
|
1495
|
+
expect(priceOf(engine, 'seg-2', 'b')).toBe(500);
|
|
1496
|
+
// De-selected C keeps its own price; nothing drifts.
|
|
1497
|
+
expect(priceOf(engine, 'seg-1', 'c')).toBe(600);
|
|
1498
|
+
expect(priceOf(engine, 'seg-2', 'c')).toBe(600);
|
|
1499
|
+
});
|
|
1500
|
+
it('de-selecting a raised half on the SAME engine returns it to its own price', () => {
|
|
1501
|
+
let engine = buildEngine();
|
|
1502
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1503
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1504
|
+
engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
1505
|
+
expect(priceOf(engine, 'seg-1', 'b')).toBe(600);
|
|
1506
|
+
// B+C -> C+D
|
|
1507
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_c', true);
|
|
1508
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_d', true);
|
|
1509
|
+
engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
1510
|
+
expect(priceOf(engine, 'seg-1', 'c')).toBe(600);
|
|
1511
|
+
expect(priceOf(engine, 'seg-2', 'd')).toBe(600);
|
|
1512
|
+
expect(priceOf(engine, 'seg-1', 'b')).toBe(500);
|
|
1513
|
+
expect(priceOf(engine, 'seg-2', 'b')).toBe(500);
|
|
1514
|
+
});
|
|
1515
|
+
it('re-applying without a selection change is stable (no drift)', () => {
|
|
1516
|
+
let engine = buildEngine();
|
|
1517
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
|
|
1518
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_d', true);
|
|
1519
|
+
const once = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
1520
|
+
const twice = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(once);
|
|
1521
|
+
expect(priceOf(twice, 'seg-1', 'a')).toBe(priceOf(once, 'seg-1', 'a'));
|
|
1522
|
+
expect(priceOf(twice, 'seg-2', 'd')).toBe(priceOf(once, 'seg-2', 'd'));
|
|
1523
|
+
expect(twice).toEqual(once);
|
|
1524
|
+
});
|
|
1525
|
+
it('modern flow: a de-structured line with raised segment prices re-bases from the definition', () => {
|
|
1526
|
+
const workable = (0, halfhalf_setup_helpers_1.convertHalfHalfSetupToWorkableHalfHalfSetup)([setup()], itemsMap, PLATFORM, TENANT_ID)[0];
|
|
1527
|
+
// Persisted edit state: segment 1 carries B at the previously charged 600.
|
|
1528
|
+
const segmentB = { ...(0, order_engine_1.convertItemToOrderItem)(workable.items[1], null, PLATFORM, TENANT_ID), price: 600 };
|
|
1529
|
+
// B + C: the raise is recomputed from the definition (500 -> 600), not
|
|
1530
|
+
// accumulated on the persisted price, and the baseline stays the catalog.
|
|
1531
|
+
const premium = (0, halfhalf_setup_helpers_1.convertHalfHalfToOrderEngineItem)({
|
|
1532
|
+
halfHalfItem: workable,
|
|
1533
|
+
selectedHalfHalfItems: [segmentB, (0, order_engine_1.convertItemToOrderItem)(workable.items[2], null, PLATFORM, TENANT_ID)],
|
|
1534
|
+
quantity: 1,
|
|
1535
|
+
platform: PLATFORM,
|
|
1536
|
+
chooseExpensiveSegmentPrice: true,
|
|
1537
|
+
});
|
|
1538
|
+
expect(priceOf(premium, 'seg-1', 'b')).toBe(600);
|
|
1539
|
+
expect(priceOf(premium, 'seg-1', 'b', true)).toBe(500);
|
|
1540
|
+
// User changes to A + B: the persisted 600 must drop to the definition 500.
|
|
1541
|
+
const cheap = (0, halfhalf_setup_helpers_1.convertHalfHalfToOrderEngineItem)({
|
|
1542
|
+
halfHalfItem: workable,
|
|
1543
|
+
selectedHalfHalfItems: [(0, order_engine_1.convertItemToOrderItem)(workable.items[0], null, PLATFORM, TENANT_ID), segmentB],
|
|
1544
|
+
quantity: 1,
|
|
1545
|
+
platform: PLATFORM,
|
|
1546
|
+
chooseExpensiveSegmentPrice: true,
|
|
1547
|
+
});
|
|
1548
|
+
expect(priceOf(cheap, 'seg-1', 'a')).toBe(500);
|
|
1549
|
+
expect(priceOf(cheap, 'seg-2', 'b')).toBe(500);
|
|
1550
|
+
});
|
|
1551
|
+
});
|