foodbot-cart-calculations 1.0.7 → 1.0.8-dev.1

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.
Files changed (6) hide show
  1. package/calculations.js +65 -12
  2. package/functions/pointsCalculation.js +220 -89
  3. package/functions/promotionCalculation.js +366 -266
  4. package/functions/taxCalculation.js +58 -38
  5. package/index.js +793 -69
  6. package/package.json +1 -1
package/calculations.js CHANGED
@@ -7,8 +7,19 @@ function applyDistribution(body) {
7
7
  body.discount = 0
8
8
  let mainCart = body
9
9
  let promotion = (body.promotion_applied && body.promotion_applied) ? body.promotion_applied : {};
10
+ let deliveryCost = (body.delivery_cost && body.delivery_cost) ? body.delivery_cost : 0;
11
+
12
+ if(body?.order_items?.delivery_discount) {
13
+ body.order_items.delivery_discount = 0
14
+ body.order_items.is_delivery_discount = false
15
+ }
16
+ if (body?.order_items?.service_discount) {
17
+ body.order_items.service_discount = 0;
18
+ body.order_items.is_service_discount = false;
19
+ }
20
+
10
21
  promoCalculation.setPackageDefaultDiscount(body.order_items).then(res => {
11
- promoCalculation.offerCalculation(res, promotion).then(final => {
22
+ promoCalculation.offerCalculation(res, promotion, deliveryCost).then(final => {
12
23
 
13
24
  let taxSettings = (body.tax_settings && body.tax_settings.length > 0) ? body.tax_settings : []
14
25
  let taxType = (body.tax_type) ? body.tax_type : 1
@@ -23,9 +34,9 @@ function applyDistribution(body) {
23
34
  body.promotion_applied = body.promotions_applied
24
35
  }
25
36
  mainCart.store_value = 0;
26
-
27
- pointsCalculation.getPointsDiscount(final, body.loyalty_points_details, body.user_detais).then(pointsCal => {
28
-
37
+ const originalDeliveryDiscount = final.delivery_discount;
38
+ const originalIsDeliveryDiscount = final.is_delivery_discount;
39
+ pointsCalculation.getPointsDiscount(final, body.loyalty_points_details, body.user_detais, body.delivery_cost, body.service_amount).then(pointsCal => {
29
40
  if (typeof (final.store_value) == "undefined" || isNaN(final.store_value))
30
41
  final.store_value = 0
31
42
  if (body.loyalty_points_details && parseInt(body.loyalty_points_details.points_redeemed) == 0) {
@@ -52,6 +63,8 @@ function applyDistribution(body) {
52
63
  }
53
64
  taxCalculation.calculateTax2(final, taxSettings, taxType).then(taxData => {
54
65
  taxData.sub_total = taxData.cartTotal;
66
+ mainCart.final_amount = parseFloat(taxData.cartTotal);
67
+ mainCart.cash_expected = parseFloat(taxData.cartTotal) ;
55
68
  taxData.total_after_tax = taxData.cartTotal
56
69
  if (body.tax_type == 2) {
57
70
  taxData.sub_total = taxData.cartTotal - taxData.tax_amount
@@ -59,30 +72,70 @@ function applyDistribution(body) {
59
72
  }
60
73
  else {
61
74
  taxData.total_after_tax = parseFloat(taxData.cartTotal) + parseFloat(taxData.tax_amount)
62
- taxData.total_after_tax = parseFloat(taxData.total_after_tax).toFixed(2)
75
+ taxData.total_after_tax = parseFloat(taxData.total_after_tax).toFixed(2);
76
+
77
+ mainCart.final_amount = parseFloat(taxData.cartTotal) + parseFloat(taxData.tax_amount);
78
+ mainCart.cash_expected = parseFloat(taxData.cartTotal) + parseFloat(taxData.tax_amount);
79
+ }
80
+ mainCart.order_items = taxData
81
+
82
+ let delivery_cost = body.delivery_cost ? body.delivery_cost : 0;
83
+ let service_amount = body.service_amount ? body.service_amount : 0;
84
+
85
+ // Adjust delivery cost based on delivery discount
86
+ if (originalIsDeliveryDiscount) {
87
+ delivery_cost = Math.max(0, delivery_cost - parseFloat(originalDeliveryDiscount));
88
+ body.delivery_cost = delivery_cost;
89
+ mainCart.order_items.delivery_discount = parseFloat(originalDeliveryDiscount);
90
+ mainCart.order_items.is_delivery_discount = true;
91
+ console.log("✅ Applied delivery discount:", { delivery_cost, body_delivery_cost: body.delivery_cost, order_items: mainCart.order_items });
63
92
  }
64
93
 
94
+ if (final.is_delivery_discount) {
95
+ delivery_cost = Math.max(0, delivery_cost - final.delivery_discount);
96
+ body.delivery_cost = delivery_cost;
97
+ }
98
+
99
+ // Adjust service amount based on service discount
100
+ if (final.is_service_discount) {
101
+ service_amount = Math.max(0, service_amount - final.service_discount);
102
+ body.service_amount = service_amount;
103
+ }
104
+ //we took 2 value because in case of absolute we use tipValue
65
105
  let tipValue = body.tip_value?body.tip_value:0;
106
+ let tipValueReq = body.tip_value?body.tip_value:0;
66
107
 
67
108
  if (body.tip_type && body.tip_type == 'percentage') {
68
- tipValue = (taxData.total_after_tax * parseInt(tipValue)) / 100
69
- tipValue = parseFloat(tipValue).toFixed(2)
109
+ tipValue = (mainCart.final_amount * parseInt(tipValueReq)) / 100
110
+ tipValue = parseFloat(tipValue).toFixed(2)
70
111
  }
71
112
 
72
- taxData.total_after_tax = parseFloat(taxData.total_after_tax) + parseFloat(tipValue);
113
+ mainCart.tip_amount = parseFloat(tipValue).toFixed(2);
73
114
 
115
+ mainCart.final_amount = parseFloat(mainCart.final_amount) + parseFloat(delivery_cost) + parseFloat(service_amount);
116
+ mainCart.cash_expected = parseFloat(mainCart.cash_expected) + parseFloat(delivery_cost) + parseFloat(service_amount);
117
+
118
+ //In a case when calculation of order done from pos.
119
+ if (body.tip_type && body.tip_type == 'percentage' && body.isPos && body.isPos == 1) {
120
+ tipValue = (mainCart.final_amount * parseInt(tipValueReq)) / 100;
121
+ tipValue = parseFloat(tipValue).toFixed(2)
122
+ }
123
+
124
+ taxData.total_after_tax = parseFloat(taxData.total_after_tax) + parseFloat(tipValue);
125
+ taxData.total_after_tax = parseFloat(taxData.total_after_tax).toFixed(2);
74
126
 
75
- mainCart.order_items = taxData
76
- mainCart.final_amount = taxData.cartTotal
77
- mainCart.cash_expected = taxData.cartTotal
78
127
  mainCart.final_amount = parseFloat(mainCart.final_amount) + parseFloat(tipValue);
79
128
  mainCart.cash_expected = parseFloat(mainCart.cash_expected) + parseFloat(tipValue);
80
129
 
81
- mainCart.order_items.discount = parseFloat(mainCart.order_items.discount) + parseFloat(mainCart.store_value)
130
+ taxData.final_amount = parseFloat(taxData.final_amount).toFixed(2);
131
+ taxData.cash_expected = parseFloat(taxData.cash_expected).toFixed(2);
132
+
133
+ mainCart.order_items.discount = parseFloat(mainCart.order_items.discount) ;
82
134
  mainCart.order_items.discount = parseFloat(mainCart.order_items.discount).toFixed(2)
83
135
 
84
136
  mainCart.discount = mainCart.order_items.discount;
85
137
  mainCart.order_items.total=parseFloat(mainCart.order_items.total).toFixed(2)
138
+
86
139
  resolve(mainCart);
87
140
  }).catch(err => {
88
141
  reject(err);
package/functions/pointsCalculation.js CHANGED
@@ -1,9 +1,12 @@
1
- function getPointsDiscount(cartObject, points, userDetails) {
1
+ function getPointsDiscount(cartObject, points, userDetails, deliveryCost = 0, serviceAmount = 0) {
2
2
  return new Promise(function (resolve, reject) {
3
3
  try {
4
4
  let itemsTotal = 0
5
5
  let carts = cartObject.item_details
6
+ let deliveryDiscount = 0;
7
+ let serviceDiscount = 0;
6
8
 
9
+ // reset old discounts
7
10
  carts.forEach(function (v) {
8
11
  delete v.points_discount_modifier;
9
12
  delete v.points_discount;
@@ -32,12 +35,15 @@ function getPointsDiscount(cartObject, points, userDetails) {
32
35
  });
33
36
  }
34
37
  });
38
+
35
39
  if (!points) {
36
- resolve(0);
40
+ cartObject.delivery_discount = 0;
41
+ cartObject.service_discount = 0;
42
+ resolve(cartObject);
37
43
  } else {
38
- let pointsAmount = '0';
44
+ let pointsAmount = 0;
39
45
  let count = 0;
40
- let storeAmount = points.store_value;
46
+ let storeAmount = points.store_value ?? (points.original_store_value ?? 0);
41
47
  let indexes = [];
42
48
 
43
49
  if (points.redeem_categories && points.redeem_categories != '') {
@@ -71,113 +77,238 @@ function getPointsDiscount(cartObject, points, userDetails) {
71
77
  element.point_discount_status = true;
72
78
  }
73
79
  count++;
80
+ });
74
81
 
75
- if (count == carts.length) {
76
- let singlePriceDiscount = pointsAmount / itemsTotal;
77
- singlePriceDiscount = parseFloat(singlePriceDiscount).toFixed(6);
82
+ // Apply points to service charge if enabled
83
+ if (points.enable_service_charge_usage === 1 && serviceAmount > 0 && storeAmount > 0) {
84
+ // Check if service discount is already applied through promotions
85
+ let hasServicePromo = cartObject.is_service_discount === true;
86
+
87
+ if (!hasServicePromo) {
88
+ cartObject.is_service_discount = true;
89
+ if (parseFloat(storeAmount) >= parseFloat(serviceAmount)) {
90
+ serviceDiscount = parseFloat(serviceAmount);
91
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(serviceAmount);
92
+ storeAmount = parseFloat(storeAmount) - parseFloat(serviceAmount);
93
+ } else {
94
+ serviceDiscount = parseFloat(storeAmount);
95
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(storeAmount);
96
+ storeAmount = 0;
97
+ }
98
+ serviceDiscount = parseFloat(serviceDiscount).toFixed(2);
99
+ cartObject.service_discount = serviceDiscount;
100
+ } else {
101
+ cartObject.service_discount = cartObject.service_discount || 0;
102
+ }
103
+ } else {
104
+ cartObject.service_discount = cartObject.service_discount || 0;
105
+ if (!cartObject.is_service_discount) {
106
+ cartObject.is_service_discount = false;
107
+ }
108
+ }
78
109
 
79
- let storeValue = 0
80
- let itemDiscount = 0;
81
- let itemTotalDicount = 0;
110
+ // Apply points to delivery if enabled and no delivery promotion is already applied
111
+ if (points.enable_delivery_points_usage === 1 && deliveryCost > 0 && storeAmount > 0) {
112
+ // Check if delivery discount is already applied through promotions
113
+ let hasDeliveryPromo = cartObject.is_delivery_discount === true;
82
114
 
83
- carts.forEach((item, index) => {
84
- item.points_discount = item.points_discount ? item.points_discount : 0;
85
- item.points_discount_modifier = item.points_discount_modifier ? item.points_discount_modifier : 0;
115
+ if (!hasDeliveryPromo) {
116
+ cartObject.is_delivery_discount = true;
117
+ if (parseFloat(storeAmount) >= parseFloat(deliveryCost)) {
118
+ deliveryDiscount = parseFloat(deliveryCost);
119
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(deliveryCost);
120
+ storeAmount = parseFloat(storeAmount) - parseFloat(deliveryCost);
121
+ } else {
122
+ deliveryDiscount = parseFloat(storeAmount);
123
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(storeAmount);
124
+ storeAmount = 0;
125
+ }
126
+ deliveryDiscount = parseFloat(deliveryDiscount).toFixed(2);
127
+ cartObject.delivery_discount = deliveryDiscount;
128
+ } else {
129
+ // If delivery promotion is already applied, preserve existing discount
130
+ cartObject.delivery_discount = cartObject.delivery_discount || 0;
131
+ }
132
+ } else {
133
+ cartObject.delivery_discount = cartObject.delivery_discount || 0;
134
+ if (!cartObject.is_delivery_discount) {
135
+ cartObject.is_delivery_discount = false;
136
+ }
137
+ }
86
138
 
87
- if (item.isPackage == 1) {
88
- if (item.point_discount_status) {
89
- let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
90
- itemDiscount = ((item.item_price * item.quantity) - promoDiscount) * singlePriceDiscount;
91
- itemDiscount = parseFloat(itemDiscount).toFixed(2);
92
- itemTotalDicount = parseFloat(itemDiscount) + parseFloat(itemTotalDicount);
139
+ if (count == carts.length) {
140
+ let singlePriceDiscount = pointsAmount / itemsTotal;
141
+ singlePriceDiscount = (itemsTotal && itemsTotal > 0)?parseFloat(singlePriceDiscount).toFixed(6):0;
93
142
 
94
- if (itemDiscount > 0)
95
- indexes.push(index);
143
+ let indexes = [];
144
+ let itemTotalDicount = 0;
96
145
 
97
- item.points_discount = itemDiscount;
98
- item.points_discount_modifier = 0;
146
+ carts.forEach((item, index) => {
147
+ item.points_discount = item.points_discount ? item.points_discount : 0;
148
+ item.points_discount_modifier = item.points_discount_modifier ? item.points_discount_modifier : 0;
99
149
 
100
- let packDis = 0;
150
+ // Replace the package items section (around line 120-170) with this corrected version:
101
151
 
102
- item.package_items.forEach((packageItem, packageItemIndex) => {
103
- let packageItemPromoDiscount = (packageItem.promotion_discount) ? packageItem.promotion_discount : 0;
104
- packageItem.points_discount_modifier = 0;
152
+ if (item.isPackage == 1) {
153
+ if (item.point_discount_status) {
154
+ let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
155
+ let itemDiscount = ((item.item_price * item.quantity) - promoDiscount) * singlePriceDiscount;
156
+ itemDiscount = parseFloat(itemDiscount).toFixed(2);
157
+
158
+ // Cap item discount to not exceed actual item price
159
+ let maxItemDiscount = (item.item_price * item.quantity) - promoDiscount;
160
+ if (parseFloat(itemDiscount) > maxItemDiscount) {
161
+ itemDiscount = parseFloat(maxItemDiscount).toFixed(2);
162
+ }
163
+
164
+ if (itemDiscount > 0)
165
+ indexes.push(index);
166
+
167
+ let totalPackageItemsDiscount = 0;
168
+ let totalPackageModifiersDiscount = 0;
169
+
170
+ item.package_items.forEach((packageItem, packageItemIndex) => {
171
+ let packageItemPromoDiscount = (packageItem.promotion_discount) ? packageItem.promotion_discount : 0;
172
+ packageItem.points_discount_modifier = 0;
173
+
174
+ // Calculate base package item price
175
+ let packageItemBasePrice = (packageItem.price * parseInt(item.quantity)) - parseFloat(packageItem.default_combo_discount || 0) - parseFloat(packageItemPromoDiscount);
176
+
177
+ // Ensure base price is not negative
178
+ if (packageItemBasePrice < 0) {
179
+ packageItemBasePrice = 0;
180
+ }
181
+
182
+ // Calculate discount for package item
183
+ let packageItemDiscount = (packageItemBasePrice * parseFloat(singlePriceDiscount));
184
+ packageItemDiscount = parseFloat(packageItemDiscount).toFixed(2);
185
+
186
+ // Cap package item discount to not exceed its actual price
187
+ if (parseFloat(packageItemDiscount) > packageItemBasePrice) {
188
+ packageItemDiscount = parseFloat(packageItemBasePrice).toFixed(2);
189
+ }
190
+
191
+ // Ensure discount is not negative
192
+ if (parseFloat(packageItemDiscount) < 0) {
193
+ packageItemDiscount = "0.00";
194
+ }
195
+
196
+ packageItem.points_discount = packageItemDiscount;
197
+ totalPackageItemsDiscount = parseFloat(totalPackageItemsDiscount) + parseFloat(packageItemDiscount);
198
+
199
+ // Handle modifiers
200
+ if (packageItem.modifiers && packageItem.modifiers.length > 0) {
201
+ packageItem.modifiers.forEach((modi, modiIndex) => {
202
+ let modiPromoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0;
203
+
204
+ // Calculate modifier base price
205
+ let modiBasePrice = (parseFloat(modi.modifier_item_price) * parseInt(modi.quantity)) * item.quantity - modiPromoDiscount;
206
+
207
+ // Ensure modifier base price is not negative
208
+ if (modiBasePrice < 0) {
209
+ modiBasePrice = 0;
210
+ }
211
+
212
+ let modiItemAmount = (modiBasePrice * parseFloat(singlePriceDiscount));
213
+ modiItemAmount = parseFloat(modiItemAmount).toFixed(2);
214
+
215
+ // Cap modifier discount
216
+ if (parseFloat(modiItemAmount) > modiBasePrice) {
217
+ modiItemAmount = parseFloat(modiBasePrice).toFixed(2);
218
+ }
219
+
220
+ // Ensure discount is not negative
221
+ if (parseFloat(modiItemAmount) < 0) {
222
+ modiItemAmount = "0.00";
223
+ }
224
+
225
+ modi.points_discount = modiItemAmount;
226
+ packageItem.points_discount_modifier = (parseFloat(packageItem.points_discount_modifier) + parseFloat(modi.points_discount)).toFixed(2);
227
+ totalPackageModifiersDiscount = parseFloat(totalPackageModifiersDiscount) + parseFloat(modiItemAmount);
228
+ });
229
+ }
230
+ });
231
+
232
+ // Set main package item discounts to reflect total of package items
233
+ item.points_discount = parseFloat(totalPackageItemsDiscount).toFixed(2);
234
+ item.points_discount_modifier = parseFloat(totalPackageModifiersDiscount).toFixed(2);
235
+
236
+ // Add to cart-level total
237
+ itemTotalDicount = parseFloat(itemTotalDicount) + parseFloat(totalPackageItemsDiscount) + parseFloat(totalPackageModifiersDiscount);
238
+ itemTotalDicount = parseFloat(itemTotalDicount).toFixed(2);
239
+ }
240
+ } else {
241
+ if (item.point_discount_status) {
242
+ let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
105
243
 
106
- packageItem.points_discount = ((((packageItem.price * parseInt(item.quantity)) - parseFloat((packageItem.default_combo_discount)) - parseFloat(packageItemPromoDiscount))) * parseFloat(singlePriceDiscount)).toFixed(2);
107
- packDis = (parseFloat(packDis) + parseFloat(packageItem.points_discount)).toFixed(2);
244
+ // --- Base item discount ---
245
+ let basePrice = parseFloat(item.item_price) * item.quantity;
246
+ let baseDiscount = ((basePrice - promoDiscount) * singlePriceDiscount);
247
+ baseDiscount = parseFloat(baseDiscount).toFixed(2);
108
248
 
109
- packageItem.modifiers.forEach((modi, modiIndex) => {
110
- let modiItemAmount = 0;
111
- let modiPromoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0;
112
- modiItemAmount = (((parseFloat(modi.modifier_item_price) * parseInt(modi.quantity)) * item.quantity) - modiPromoDiscount) * parseFloat(singlePriceDiscount);
113
- modiItemAmount = parseFloat(modiItemAmount).toFixed(2);
114
- itemTotalDicount = parseFloat(itemTotalDicount) + parseFloat(modiItemAmount);
115
- itemTotalDicount = parseFloat(itemTotalDicount).toFixed(2);
116
- modi.points_discount = modiItemAmount;
117
- packageItem.points_discount_modifier = (parseFloat(packageItem.points_discount_modifier) + parseFloat(modi.points_discount)).toFixed(2);
118
- });
119
- packageItem.points_discount_modifier = (parseFloat(packageItem.points_discount) + parseFloat(packageItem.points_discount_modifier)).toFixed(2);
120
- });
249
+ // cap base discount
250
+ if (parseFloat(baseDiscount) > basePrice) {
251
+ baseDiscount = basePrice.toFixed(2);
252
+ }
121
253
 
122
- if (itemDiscount != packDis && item.package_items) {
123
- if (packDis > itemDiscount) {
124
- let diff = (parseFloat(packDis) - parseFloat(itemDiscount)).toFixed(2);
125
- item.package_items[0].points_discount = (parseFloat(item.package_items[0].points_discount) - parseFloat(diff)).toFixed(2);
126
- } else {
127
- let diff = (parseFloat(itemDiscount) - parseFloat(packDis)).toFixed(2);
128
- item.package_items[0].points_discount = (parseFloat(item.package_items[0].points_discount) - parseFloat(diff)).toFixed(2);
129
- }
130
- }
254
+ if (parseFloat(baseDiscount) > 0) {
255
+ indexes.push(index);
131
256
  }
132
- } else {
133
- if (item.point_discount_status) {
134
- let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
135
- itemDiscount = ((item.item_price * item.quantity) - promoDiscount) * singlePriceDiscount;
136
- itemDiscount = parseFloat(itemDiscount).toFixed(2);
137
- itemTotalDicount = parseFloat(itemDiscount) + parseFloat(itemTotalDicount);
138
-
139
- if (itemDiscount > 0)
140
- indexes.push(index);
141
-
142
- item.points_discount = itemDiscount;
143
-
144
- item.item_modifiers.forEach((modi, modiIndex) => {
145
- let modiItemAmount = 0;
146
- let modiPromoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0;
147
- modiItemAmount = (((parseFloat(modi.modifier_item_price) * parseInt(modi.quantity)) * item.quantity) - modiPromoDiscount) * parseFloat(singlePriceDiscount);
148
- modiItemAmount = parseFloat(modiItemAmount).toFixed(2);
149
- itemTotalDicount = parseFloat(itemTotalDicount) + parseFloat(modiItemAmount);
150
- itemTotalDicount = parseFloat(itemTotalDicount).toFixed(2);
151
- modi.points_discount = modiItemAmount;
257
+ item.points_discount = baseDiscount;
258
+
259
+ // --- Modifiers ---
260
+ let modsTotalDiscount = 0;
261
+ if (item.item_modifiers && item.item_modifiers.length > 0) {
262
+ item.item_modifiers.forEach((modi) => {
263
+ let modiBase = parseFloat(modi.modifier_item_price) * modi.quantity * item.quantity;
264
+ let modiDiscount = (modiBase * parseFloat(singlePriceDiscount));
265
+ modiDiscount = parseFloat(modiDiscount).toFixed(2);
266
+
267
+ // cap modifier
268
+ if (parseFloat(modiDiscount) > modiBase) {
269
+ modiDiscount = modiBase.toFixed(2);
270
+ }
271
+
272
+ modi.points_discount = modiDiscount;
273
+ modsTotalDiscount = (parseFloat(modsTotalDiscount) + parseFloat(modiDiscount)).toFixed(2);
152
274
  });
275
+ }
276
+ item.points_discount_modifier = modsTotalDiscount;
153
277
 
154
- item.points_discount_modifier = itemTotalDicount;
278
+ // --- cap total item discount ---
279
+ let itemMax = parseFloat(item.item_price_with_modifier) * item.quantity;
280
+ let totalItemDiscount = parseFloat(item.points_discount) + parseFloat(item.points_discount_modifier);
281
+ if (totalItemDiscount > itemMax) {
282
+ let overflow = totalItemDiscount - itemMax;
283
+ if (parseFloat(item.points_discount_modifier) >= overflow) {
284
+ item.points_discount_modifier = (parseFloat(item.points_discount_modifier) - overflow).toFixed(2);
285
+ } else {
286
+ let leftover = overflow - parseFloat(item.points_discount_modifier);
287
+ item.points_discount_modifier = "0.00";
288
+ item.points_discount = (parseFloat(item.points_discount) - leftover).toFixed(2);
289
+ }
155
290
  }
156
- }
157
- });
158
291
 
159
- if ((Number(itemTotalDicount) < Number(pointsAmount) || Number(itemTotalDicount) > Number(pointsAmount)) && pointsAmount > 0 && itemTotalDicount > 0) {
160
- let difference = Number(pointsAmount) - Number(itemTotalDicount);
161
- difference = parseFloat(difference).toFixed(2);
162
- if (index > -1) {
163
- carts[indexes[0]].points_discount = (difference > 0) ? parseFloat(carts[indexes[0]].points_discount) + parseFloat(difference) : parseFloat(carts[indexes[0]].points_discount) - Math.abs(difference);
164
- carts[indexes[0]].points_discount = parseFloat(carts[indexes[0]].points_discount).toFixed(2);
165
- itemTotalDicount = (difference < 0) ? itemTotalDicount + difference : itemTotalDicount - Math.abs(difference);
166
- itemTotalDicount = parseFloat(itemTotalDicount).toFixed(2);
292
+ // add to cart-level total
293
+ itemTotalDicount = (parseFloat(itemTotalDicount) + parseFloat(item.points_discount) + parseFloat(item.points_discount_modifier)).toFixed(2);
167
294
  }
168
295
  }
296
+ });
169
297
 
170
- cartObject.item_details = carts
171
- cartObject.store_value = pointsAmount
172
- cartObject.point_discount_amount = pointsAmount
298
+ cartObject.item_details = carts
299
+ cartObject.store_value = pointsAmount
300
+ cartObject.point_discount_amount = pointsAmount
301
+ cartObject.delivery_discount = deliveryDiscount;
302
+ cartObject.service_discount = serviceDiscount;
173
303
 
174
- resolve(cartObject);
175
- }
176
- });
304
+ resolve(cartObject);
305
+ }
177
306
  } else {
178
307
  cartObject.item_details = carts
179
- cartObject.store_value = pointsAmount
180
- cartObject.point_discount_amount = pointsAmount
308
+ cartObject.store_value = 0
309
+ cartObject.point_discount_amount = 0
310
+ cartObject.delivery_discount = 0;
311
+ cartObject.service_discount = 0;
181
312
 
182
313
  resolve(cartObject);
183
314
  }