foodbot-cart-calculations 1.0.4 → 1.0.5-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 +59 -12
  2. package/functions/pointsCalculation.js +201 -89
  3. package/functions/promotionCalculation.js +382 -282
  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,64 @@ 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);
63
79
  }
80
+ mainCart.order_items = taxData
64
81
 
82
+ let delivery_cost = body.delivery_cost ? body.delivery_cost : 0;
83
+ let service_amount = body.service_amount ? body.service_amount : 0;
84
+ // Adjust delivery cost based on delivery discount
85
+ if (originalIsDeliveryDiscount) {
86
+ delivery_cost = Math.max(0, delivery_cost - parseFloat(originalDeliveryDiscount));
87
+ body.delivery_cost = delivery_cost;
88
+ mainCart.order_items.delivery_discount = parseFloat(originalDeliveryDiscount);
89
+ mainCart.order_items.is_delivery_discount = true;
90
+ console.log("✅ Applied delivery discount:", { delivery_cost, body_delivery_cost: body.delivery_cost, order_items: mainCart.order_items });
91
+ }
92
+
93
+ // Adjust service amount based on service discount
94
+ if (final.is_service_discount) {
95
+ service_amount = Math.max(0, service_amount - final.service_discount);
96
+ body.service_amount = service_amount;
97
+ }
98
+ //we took 2 value because in case of absolute we use tipValue
65
99
  let tipValue = body.tip_value?body.tip_value:0;
100
+ let tipValueReq = body.tip_value?body.tip_value:0;
66
101
 
67
102
  if (body.tip_type && body.tip_type == 'percentage') {
68
- tipValue = (taxData.total_after_tax * parseInt(tipValue)) / 100
69
- tipValue = parseFloat(tipValue).toFixed(2)
103
+ tipValue = (mainCart.final_amount * parseInt(tipValueReq)) / 100
104
+ tipValue = parseFloat(tipValue).toFixed(2)
70
105
  }
71
106
 
72
- taxData.total_after_tax = parseFloat(taxData.total_after_tax) + parseFloat(tipValue);
107
+ mainCart.tip_amount = parseFloat(tipValue).toFixed(2);
73
108
 
109
+ mainCart.final_amount = parseFloat(mainCart.final_amount) + parseFloat(delivery_cost) + parseFloat(service_amount);
110
+ mainCart.cash_expected = parseFloat(mainCart.cash_expected) + parseFloat(delivery_cost) + parseFloat(service_amount);
111
+
112
+ //In a case when calculation of order done from pos.
113
+ if (body.tip_type && body.tip_type == 'percentage' && body.isPos && body.isPos == 1) {
114
+ tipValue = (mainCart.final_amount * parseInt(tipValueReq)) / 100;
115
+ tipValue = parseFloat(tipValue).toFixed(2)
116
+ }
117
+
118
+ taxData.total_after_tax = parseFloat(taxData.total_after_tax) + parseFloat(tipValue);
119
+ taxData.total_after_tax = parseFloat(taxData.total_after_tax).toFixed(2);
74
120
 
75
- mainCart.order_items = taxData
76
- mainCart.final_amount = taxData.cartTotal
77
- mainCart.cash_expected = taxData.cartTotal
78
121
  mainCart.final_amount = parseFloat(mainCart.final_amount) + parseFloat(tipValue);
79
122
  mainCart.cash_expected = parseFloat(mainCart.cash_expected) + parseFloat(tipValue);
80
123
 
81
- mainCart.order_items.discount = parseFloat(mainCart.order_items.discount) + parseFloat(mainCart.store_value)
124
+ taxData.final_amount = parseFloat(taxData.final_amount).toFixed(2);
125
+ taxData.cash_expected = parseFloat(taxData.cash_expected).toFixed(2);
126
+
127
+ mainCart.order_items.discount = parseFloat(mainCart.order_items.discount) ;
82
128
  mainCart.order_items.discount = parseFloat(mainCart.order_items.discount).toFixed(2)
83
129
 
84
130
  mainCart.discount = mainCart.order_items.discount;
85
131
  mainCart.order_items.total=parseFloat(mainCart.order_items.total).toFixed(2)
132
+
86
133
  resolve(mainCart);
87
134
  }).catch(err => {
88
135
  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,219 @@ 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
+ cartObject.is_service_discount = true;
85
+ if (parseFloat(storeAmount) >= parseFloat(serviceAmount)) {
86
+ serviceDiscount = parseFloat(serviceAmount);
87
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(serviceAmount);
88
+ storeAmount = parseFloat(storeAmount) - parseFloat(serviceAmount);
89
+ } else {
90
+ serviceDiscount = parseFloat(storeAmount);
91
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(storeAmount);
92
+ storeAmount = 0;
93
+ }
94
+ serviceDiscount = parseFloat(serviceDiscount).toFixed(2);
95
+ cartObject.service_discount = serviceDiscount;
96
+ } else {
97
+ cartObject.service_discount = 0;
98
+ cartObject.is_service_discount = false;
99
+ }
78
100
 
79
- let storeValue = 0
80
- let itemDiscount = 0;
81
- let itemTotalDicount = 0;
101
+ // Apply points to delivery if enabled
102
+ if (points.enable_delivery_points_usage === 1 && deliveryCost > 0 && storeAmount > 0) {
103
+ cartObject.is_delivery_discount = true;
104
+ if (parseFloat(storeAmount) >= parseFloat(deliveryCost)) {
105
+ deliveryDiscount = parseFloat(deliveryCost);
106
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(deliveryCost);
107
+ storeAmount = parseFloat(storeAmount) - parseFloat(deliveryCost);
108
+ } else {
109
+ deliveryDiscount = parseFloat(storeAmount);
110
+ pointsAmount = parseFloat(pointsAmount) + parseFloat(storeAmount);
111
+ storeAmount = 0;
112
+ }
113
+ deliveryDiscount = parseFloat(deliveryDiscount).toFixed(2);
114
+ cartObject.delivery_discount = deliveryDiscount;
115
+ } else {
116
+ cartObject.delivery_discount = 0;
117
+ cartObject.is_delivery_discount = false;
118
+ }
119
+
120
+ if (count == carts.length) {
121
+ let singlePriceDiscount = pointsAmount / itemsTotal;
122
+ singlePriceDiscount = (itemsTotal && itemsTotal > 0)?parseFloat(singlePriceDiscount).toFixed(6):0;
82
123
 
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;
124
+ let indexes = [];
125
+ let itemTotalDicount = 0;
86
126
 
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);
127
+ carts.forEach((item, index) => {
128
+ item.points_discount = item.points_discount ? item.points_discount : 0;
129
+ item.points_discount_modifier = item.points_discount_modifier ? item.points_discount_modifier : 0;
93
130
 
94
- if (itemDiscount > 0)
95
- indexes.push(index);
131
+ // Replace the package items section (around line 120-170) with this corrected version:
96
132
 
97
- item.points_discount = itemDiscount;
98
- item.points_discount_modifier = 0;
133
+ if (item.isPackage == 1) {
134
+ if (item.point_discount_status) {
135
+ let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
136
+ let itemDiscount = ((item.item_price * item.quantity) - promoDiscount) * singlePriceDiscount;
137
+ itemDiscount = parseFloat(itemDiscount).toFixed(2);
138
+
139
+ // Cap item discount to not exceed actual item price
140
+ let maxItemDiscount = (item.item_price * item.quantity) - promoDiscount;
141
+ if (parseFloat(itemDiscount) > maxItemDiscount) {
142
+ itemDiscount = parseFloat(maxItemDiscount).toFixed(2);
143
+ }
144
+
145
+ if (itemDiscount > 0)
146
+ indexes.push(index);
147
+
148
+ let totalPackageItemsDiscount = 0;
149
+ let totalPackageModifiersDiscount = 0;
150
+
151
+ item.package_items.forEach((packageItem, packageItemIndex) => {
152
+ let packageItemPromoDiscount = (packageItem.promotion_discount) ? packageItem.promotion_discount : 0;
153
+ packageItem.points_discount_modifier = 0;
154
+
155
+ // Calculate base package item price
156
+ let packageItemBasePrice = (packageItem.price * parseInt(item.quantity)) - parseFloat(packageItem.default_combo_discount || 0) - parseFloat(packageItemPromoDiscount);
157
+
158
+ // Ensure base price is not negative
159
+ if (packageItemBasePrice < 0) {
160
+ packageItemBasePrice = 0;
161
+ }
162
+
163
+ // Calculate discount for package item
164
+ let packageItemDiscount = (packageItemBasePrice * parseFloat(singlePriceDiscount));
165
+ packageItemDiscount = parseFloat(packageItemDiscount).toFixed(2);
166
+
167
+ // Cap package item discount to not exceed its actual price
168
+ if (parseFloat(packageItemDiscount) > packageItemBasePrice) {
169
+ packageItemDiscount = parseFloat(packageItemBasePrice).toFixed(2);
170
+ }
171
+
172
+ // Ensure discount is not negative
173
+ if (parseFloat(packageItemDiscount) < 0) {
174
+ packageItemDiscount = "0.00";
175
+ }
176
+
177
+ packageItem.points_discount = packageItemDiscount;
178
+ totalPackageItemsDiscount = parseFloat(totalPackageItemsDiscount) + parseFloat(packageItemDiscount);
179
+
180
+ // Handle modifiers
181
+ if (packageItem.modifiers && packageItem.modifiers.length > 0) {
182
+ packageItem.modifiers.forEach((modi, modiIndex) => {
183
+ let modiPromoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0;
184
+
185
+ // Calculate modifier base price
186
+ let modiBasePrice = (parseFloat(modi.modifier_item_price) * parseInt(modi.quantity)) * item.quantity - modiPromoDiscount;
187
+
188
+ // Ensure modifier base price is not negative
189
+ if (modiBasePrice < 0) {
190
+ modiBasePrice = 0;
191
+ }
192
+
193
+ let modiItemAmount = (modiBasePrice * parseFloat(singlePriceDiscount));
194
+ modiItemAmount = parseFloat(modiItemAmount).toFixed(2);
195
+
196
+ // Cap modifier discount
197
+ if (parseFloat(modiItemAmount) > modiBasePrice) {
198
+ modiItemAmount = parseFloat(modiBasePrice).toFixed(2);
199
+ }
200
+
201
+ // Ensure discount is not negative
202
+ if (parseFloat(modiItemAmount) < 0) {
203
+ modiItemAmount = "0.00";
204
+ }
205
+
206
+ modi.points_discount = modiItemAmount;
207
+ packageItem.points_discount_modifier = (parseFloat(packageItem.points_discount_modifier) + parseFloat(modi.points_discount)).toFixed(2);
208
+ totalPackageModifiersDiscount = parseFloat(totalPackageModifiersDiscount) + parseFloat(modiItemAmount);
209
+ });
210
+ }
211
+ });
212
+
213
+ // Set main package item discounts to reflect total of package items
214
+ item.points_discount = parseFloat(totalPackageItemsDiscount).toFixed(2);
215
+ item.points_discount_modifier = parseFloat(totalPackageModifiersDiscount).toFixed(2);
216
+
217
+ // Add to cart-level total
218
+ itemTotalDicount = parseFloat(itemTotalDicount) + parseFloat(totalPackageItemsDiscount) + parseFloat(totalPackageModifiersDiscount);
219
+ itemTotalDicount = parseFloat(itemTotalDicount).toFixed(2);
220
+ }
221
+ } else {
222
+ if (item.point_discount_status) {
223
+ let promoDiscount = (item.promotion_discount) ? item.promotion_discount : 0;
99
224
 
100
- let packDis = 0;
225
+ // --- Base item discount ---
226
+ let basePrice = parseFloat(item.item_price) * item.quantity;
227
+ let baseDiscount = ((basePrice - promoDiscount) * singlePriceDiscount);
228
+ baseDiscount = parseFloat(baseDiscount).toFixed(2);
101
229
 
102
- item.package_items.forEach((packageItem, packageItemIndex) => {
103
- let packageItemPromoDiscount = (packageItem.promotion_discount) ? packageItem.promotion_discount : 0;
104
- packageItem.points_discount_modifier = 0;
230
+ // cap base discount
231
+ if (parseFloat(baseDiscount) > basePrice) {
232
+ baseDiscount = basePrice.toFixed(2);
233
+ }
105
234
 
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);
235
+ if (parseFloat(baseDiscount) > 0) {
236
+ indexes.push(index);
237
+ }
238
+ item.points_discount = baseDiscount;
108
239
 
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
- });
240
+ // --- Modifiers ---
241
+ let modsTotalDiscount = 0;
242
+ if (item.item_modifiers && item.item_modifiers.length > 0) {
243
+ item.item_modifiers.forEach((modi) => {
244
+ let modiBase = parseFloat(modi.modifier_item_price) * modi.quantity * item.quantity;
245
+ let modiDiscount = (modiBase * parseFloat(singlePriceDiscount));
246
+ modiDiscount = parseFloat(modiDiscount).toFixed(2);
121
247
 
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);
248
+ // cap modifier
249
+ if (parseFloat(modiDiscount) > modiBase) {
250
+ modiDiscount = modiBase.toFixed(2);
129
251
  }
130
- }
131
- }
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;
252
+
253
+ modi.points_discount = modiDiscount;
254
+ modsTotalDiscount = (parseFloat(modsTotalDiscount) + parseFloat(modiDiscount)).toFixed(2);
152
255
  });
256
+ }
257
+ item.points_discount_modifier = modsTotalDiscount;
153
258
 
154
- item.points_discount_modifier = itemTotalDicount;
259
+ // --- cap total item discount ---
260
+ let itemMax = parseFloat(item.item_price_with_modifier) * item.quantity;
261
+ let totalItemDiscount = parseFloat(item.points_discount) + parseFloat(item.points_discount_modifier);
262
+ if (totalItemDiscount > itemMax) {
263
+ let overflow = totalItemDiscount - itemMax;
264
+ if (parseFloat(item.points_discount_modifier) >= overflow) {
265
+ item.points_discount_modifier = (parseFloat(item.points_discount_modifier) - overflow).toFixed(2);
266
+ } else {
267
+ let leftover = overflow - parseFloat(item.points_discount_modifier);
268
+ item.points_discount_modifier = "0.00";
269
+ item.points_discount = (parseFloat(item.points_discount) - leftover).toFixed(2);
270
+ }
155
271
  }
156
- }
157
- });
158
272
 
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);
273
+ // add to cart-level total
274
+ itemTotalDicount = (parseFloat(itemTotalDicount) + parseFloat(item.points_discount) + parseFloat(item.points_discount_modifier)).toFixed(2);
167
275
  }
168
276
  }
277
+ });
169
278
 
170
- cartObject.item_details = carts
171
- cartObject.store_value = pointsAmount
172
- cartObject.point_discount_amount = pointsAmount
279
+ cartObject.item_details = carts
280
+ cartObject.store_value = pointsAmount
281
+ cartObject.point_discount_amount = pointsAmount
282
+ cartObject.delivery_discount = deliveryDiscount;
283
+ cartObject.service_discount = serviceDiscount;
173
284
 
174
- resolve(cartObject);
175
- }
176
- });
285
+ resolve(cartObject);
286
+ }
177
287
  } else {
178
288
  cartObject.item_details = carts
179
- cartObject.store_value = pointsAmount
180
- cartObject.point_discount_amount = pointsAmount
289
+ cartObject.store_value = 0
290
+ cartObject.point_discount_amount = 0
291
+ cartObject.delivery_discount = 0;
292
+ cartObject.service_discount = 0;
181
293
 
182
294
  resolve(cartObject);
183
295
  }