@darkpos/pricing 1.0.173 → 1.0.175
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/__TEST__/order/hold.test.js +122 -0
- package/lib/order/calculate.js +5 -1
- package/lib/order/hold.js +16 -8
- package/lib/order/open.js +19 -7
- package/package.json +2 -2
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
const usePricing = require('../../index');
|
|
2
|
+
const mockStores = require('../mocks/stores');
|
|
3
|
+
const mockStoreSettings = require('../mocks/storeSettings');
|
|
4
|
+
|
|
5
|
+
const pricingService = usePricing({
|
|
6
|
+
store: mockStores[0],
|
|
7
|
+
settings: mockStoreSettings,
|
|
8
|
+
});
|
|
9
|
+
|
|
10
|
+
const item = {
|
|
11
|
+
_id: 'item-1',
|
|
12
|
+
itemId: 'item-1',
|
|
13
|
+
name: 'Shirt',
|
|
14
|
+
price: 10,
|
|
15
|
+
quantity: 1,
|
|
16
|
+
modifiers: [],
|
|
17
|
+
};
|
|
18
|
+
|
|
19
|
+
describe('calculate order status', () => {
|
|
20
|
+
test('keeps a held order on hold', () => {
|
|
21
|
+
const order = pricingService.order.holdOrder({ status: {}, items: [item] });
|
|
22
|
+
const result = pricingService.order.calculate(order);
|
|
23
|
+
expect(result.status.order).toBe('hold');
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
test('closes a held order once it is paid and picked', () => {
|
|
27
|
+
const order = pricingService.order.holdOrder({
|
|
28
|
+
status: {},
|
|
29
|
+
totalPaid: 10,
|
|
30
|
+
items: [
|
|
31
|
+
{
|
|
32
|
+
...item,
|
|
33
|
+
totalPaid: 10,
|
|
34
|
+
status: { picked: { value: true }, paid: { value: true } },
|
|
35
|
+
},
|
|
36
|
+
],
|
|
37
|
+
});
|
|
38
|
+
const result = pricingService.order.calculate(order);
|
|
39
|
+
expect(result.status.paid).toBe(true);
|
|
40
|
+
expect(result.status.picked).toBe(true);
|
|
41
|
+
expect(result.status.order).toBe('closed');
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
test('holdOrder and openOrder cascade to sub-orders, skipping closed and void ones', () => {
|
|
45
|
+
const parent = {
|
|
46
|
+
status: { order: 'open' },
|
|
47
|
+
orders: [
|
|
48
|
+
{ _id: 'a', status: { order: 'open' } },
|
|
49
|
+
{ _id: 'b', status: { order: 'closed' } },
|
|
50
|
+
{ _id: 'c', status: { order: 'void' } },
|
|
51
|
+
],
|
|
52
|
+
};
|
|
53
|
+
const held = pricingService.order.holdOrder(parent);
|
|
54
|
+
expect(held.status.order).toBe('hold');
|
|
55
|
+
expect(held.orders.map(o => o.status.order)).toEqual([
|
|
56
|
+
'hold',
|
|
57
|
+
'closed',
|
|
58
|
+
'void',
|
|
59
|
+
]);
|
|
60
|
+
|
|
61
|
+
const opened = pricingService.order.openOrder(held);
|
|
62
|
+
expect(opened.status.order).toBe('open');
|
|
63
|
+
expect(opened.orders.map(o => o.status.order)).toEqual([
|
|
64
|
+
'open',
|
|
65
|
+
'closed',
|
|
66
|
+
'void',
|
|
67
|
+
]);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
test('openOrder on a voided parent reopens its voided sub-orders', () => {
|
|
71
|
+
const opened = pricingService.order.openOrder({
|
|
72
|
+
status: { order: 'void' },
|
|
73
|
+
orders: [
|
|
74
|
+
{ _id: 'a', status: { order: 'void' } },
|
|
75
|
+
{ _id: 'b', status: { order: 'closed' } },
|
|
76
|
+
],
|
|
77
|
+
});
|
|
78
|
+
expect(opened.status.order).toBe('open');
|
|
79
|
+
expect(opened.orders.map(o => o.status.order)).toEqual(['open', 'closed']);
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
test('keeps a voided order void, even when paid and picked', () => {
|
|
83
|
+
expect(
|
|
84
|
+
pricingService.order.calculate({
|
|
85
|
+
status: { order: 'void' },
|
|
86
|
+
items: [item],
|
|
87
|
+
}).status.order
|
|
88
|
+
).toBe('void');
|
|
89
|
+
|
|
90
|
+
const paidPicked = pricingService.order.calculate({
|
|
91
|
+
status: { order: 'void' },
|
|
92
|
+
totalPaid: 10,
|
|
93
|
+
items: [
|
|
94
|
+
{
|
|
95
|
+
...item,
|
|
96
|
+
totalPaid: 10,
|
|
97
|
+
status: { picked: { value: true }, paid: { value: true } },
|
|
98
|
+
},
|
|
99
|
+
],
|
|
100
|
+
});
|
|
101
|
+
expect(paidPicked.status.order).toBe('void');
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
test('splitAndCalculate keeps held and voided sub-order statuses', () => {
|
|
105
|
+
const subOrders = pricingService.order.splitAndCalculate({
|
|
106
|
+
parentOrder: { status: { order: 'hold' }, modifiers: [], subTotal: 20 },
|
|
107
|
+
subOrders: [
|
|
108
|
+
{ _id: 'a', status: { order: 'hold' }, items: [item] },
|
|
109
|
+
{ _id: 'b', status: { order: 'void' }, items: [item] },
|
|
110
|
+
],
|
|
111
|
+
});
|
|
112
|
+
expect(subOrders.map(o => o.status.order)).toEqual(['hold', 'void']);
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
test('reopens a closed order that is no longer paid and picked', () => {
|
|
116
|
+
const result = pricingService.order.calculate({
|
|
117
|
+
status: { order: 'closed' },
|
|
118
|
+
items: [item],
|
|
119
|
+
});
|
|
120
|
+
expect(result.status.order).toBe('open');
|
|
121
|
+
});
|
|
122
|
+
});
|
package/lib/order/calculate.js
CHANGED
|
@@ -191,6 +191,10 @@ module.exports = ({
|
|
|
191
191
|
totalPaid,
|
|
192
192
|
});
|
|
193
193
|
|
|
194
|
+
let orderStatus = actions.isHold(order) ? 'hold' : 'open';
|
|
195
|
+
if (picked && paid) orderStatus = 'closed';
|
|
196
|
+
if (actions.isVoid(order)) orderStatus = 'void';
|
|
197
|
+
|
|
194
198
|
return {
|
|
195
199
|
...order,
|
|
196
200
|
subTotals,
|
|
@@ -201,7 +205,7 @@ module.exports = ({
|
|
|
201
205
|
...(order.status || {}),
|
|
202
206
|
picked,
|
|
203
207
|
paid,
|
|
204
|
-
order:
|
|
208
|
+
order: orderStatus,
|
|
205
209
|
},
|
|
206
210
|
properties: {
|
|
207
211
|
...(order.properties || {}),
|
package/lib/order/hold.js
CHANGED
|
@@ -1,12 +1,20 @@
|
|
|
1
1
|
module.exports = ({ constants }) =>
|
|
2
2
|
function holdOrder(order) {
|
|
3
3
|
if (!order) return order;
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
4
|
+
const { HOLD, CLOSED, VOID } = constants.Status.Order;
|
|
5
|
+
const setHold = each => ({
|
|
6
|
+
...each,
|
|
7
|
+
status: { ...(each.status || {}), order: HOLD },
|
|
8
|
+
});
|
|
9
|
+
|
|
10
|
+
const held = setHold(order);
|
|
11
|
+
// Sub-orders follow the parent, except closed or voided ones
|
|
12
|
+
if (Array.isArray(order.orders)) {
|
|
13
|
+
held.orders = order.orders.map(each =>
|
|
14
|
+
!each || [CLOSED, VOID].includes(each.status && each.status.order)
|
|
15
|
+
? each
|
|
16
|
+
: setHold(each)
|
|
17
|
+
);
|
|
18
|
+
}
|
|
19
|
+
return held;
|
|
12
20
|
};
|
package/lib/order/open.js
CHANGED
|
@@ -1,11 +1,23 @@
|
|
|
1
1
|
module.exports = ({ constants }) =>
|
|
2
2
|
function openOrder(order) {
|
|
3
3
|
if (!order) return order;
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
4
|
+
const { OPEN, CLOSED, VOID } = constants.Status.Order;
|
|
5
|
+
const setOpen = each => ({
|
|
6
|
+
...each,
|
|
7
|
+
status: { ...(each.status || {}), order: OPEN },
|
|
8
|
+
});
|
|
9
|
+
|
|
10
|
+
// Un-voiding a parent reopens its voided sub-orders too
|
|
11
|
+
const skipped =
|
|
12
|
+
order.status && order.status.order === VOID ? [CLOSED] : [CLOSED, VOID];
|
|
13
|
+
|
|
14
|
+
const opened = setOpen(order);
|
|
15
|
+
if (Array.isArray(order.orders)) {
|
|
16
|
+
opened.orders = order.orders.map(each =>
|
|
17
|
+
!each || skipped.includes(each.status && each.status.order)
|
|
18
|
+
? each
|
|
19
|
+
: setOpen(each)
|
|
20
|
+
);
|
|
21
|
+
}
|
|
22
|
+
return opened;
|
|
11
23
|
};
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@darkpos/pricing",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.175",
|
|
4
4
|
"description": "Pricing calculator",
|
|
5
5
|
"author": "Dark POS",
|
|
6
6
|
"license": "ISC",
|
|
@@ -54,5 +54,5 @@
|
|
|
54
54
|
"supertest": "^6.2.3",
|
|
55
55
|
"supervisor": "^0.12.0"
|
|
56
56
|
},
|
|
57
|
-
"gitHead": "
|
|
57
|
+
"gitHead": "c369da4b3f572259dcd23762f272093efdbedfa2"
|
|
58
58
|
}
|