Handling Taxes & Fees

"items": [
   {
     "reference_number": "merchant_order_number",
     "name": "Ticket 1",
     "cost": 57.50 – including all taxes and fees from the merchant
   },
 {
     "reference_number": "merchant_order_number",
     "name": "Ticket 2",
     "cost": 57.50 – including taxes and fees
   }
]

"items": [
   {
     "reference_number": "merchant_order_number",
     "name": "Ticket 1",
     "cost": 7.50, – including all taxes and fees from the merchant
   },
 {
     "reference_number": "merchant_order_number",
     "name": "Ticket 2",
     "description": "item_description",
     "cost": 37.50, – including taxes and fees
   }
]

/**
 * @summary calculates the cart subtotal and splits fees and taxes proportionally for each line item
 *
 * PARAMS
 * ============================================================================
 * @param {{cost: number; fee: number}[]} items - cart line items, including each cost and a fee specific to each item
 * @param {number} cartLevelFees - a total fee not specific to any individual item
 */
export const handleSplitFeesAndTaxes = (items, cartLevelFees) => {
  // the subtotal of each item, including item-level fees
  const itemSubtotals = items.map((item) => item.cost + item.fee);

  // the subtotal of the cart
  const cartSubtotal = itemSubtotals.reduce((acc, item) => acc + item, 0);

  // taxes at a fixed value of $5 for testing purposes
  const taxes = 5;

  // total taxes and fees that should be split proportionally for each item
  const cartLevelFeesAndTaxes = cartLevelFees + taxes;

  const itemTotals = itemSubtotals.map((item) => {
    // determine the proportion of fees and taxes that should be associated to each item
    const proportionOfFeesAndTaxes = item / cartSubtotal;

    // return the sum the item value and proportion of cart-level fees
    return +(item + cartLevelFeesAndTaxes * proportionOfFeesAndTaxes).toFixed(
      2,
    );
  });

  // sum the values of the item totals to check for rounding discrepancies
  const itemTotalsSum = itemTotals.reduce((acc, item) => acc + item, 0);

  // determine the value of the rounding difference, if any
  let diff =
    +(itemTotalsSum - (cartSubtotal + cartLevelFeesAndTaxes)).toFixed(2) * 100;

  // if no rounding discrepancy, return the item totals
  if (diff === 0) return itemTotals;

  const validatedItemTotals = itemTotals.map((item) => {
    // if there's no more discrepancy to offset, return the initial item cost
    if (diff === 0) return item;

    // decrement the rounding difference
    diff = diff - 1;

    // reduce the item cost by the smallest increment, accounting for non-decimal currencies
    return ((item * 100) - 1) / 100;
  });

  return validatedItemTotals;
};

def handle_split_fees_and_taxes(items, cart_level_fees):
    """
  @summary: calculates the cart subtotal and splits fees and taxes proportionally for each line item.

  @params:
  items (list of dicts): Each item is a dictionary with keys 'cost' and 'fee'.
  cart_level_fees (float): A total fee not specific to any individual item.
  """
    # the subtotal of each item, including item-level fees
    item_subtotals = [
        item.get('cost', 0) + item.get('fee', 0) for item in items
    ]

    # the subtotal of the cart
    cart_subtotal = sum(item_subtotals)

    # taxes at a fixed value of $5 for testing purposes
    taxes = 5

    # total taxes and fees that should be split proportionally for each item
    cart_level_fees_and_taxes = cart_level_fees + taxes

    item_totals = []
    for item in item_subtotals:
        # determine the proportion of fees and taxes that should be associated with each item
        proportion_of_fees_and_taxes = item / cart_subtotal

        # return the sum of the item value and proportion of cart-level fees
        item_total = round(
            item + cart_level_fees_and_taxes * proportion_of_fees_and_taxes, 2)
        item_totals.append(item_total)

    # sum the values of the item totals to check for rounding discrepancies
    item_totals_sum = sum(item_totals)

    # determine the value of the rounding difference, if any
    diff = round(item_totals_sum -
                 (cart_subtotal + cart_level_fees_and_taxes), 2) * 100

    # if no rounding discrepancy, return the item totals
    if diff == 0:
        return item_totals

    validated_item_totals = []
    for item in item_totals:
        # if there's no more discrepancy to offset, return the initial item cost
        if diff == 0:
            validated_item_totals.append(item)
            continue

        # decrement the rounding difference
        diff -= 1

        # reduce the item cost by the smallest increment, accounting for non-decimal currencies
        validated_item_totals.append(round((item * 100 - 1) / 100, 2))

    return validated_item_totals