Introduce a prices_sum helper to factorize the calculation on reports

Author: pacodelaluna

app/helpers/reports_helper.rb

@@ -61,4 +61,8 @@ def datepicker_time(datetime)
     datetime = Time.zone.parse(datetime) if datetime.is_a? String
     datetime.strftime('%Y-%m-%d %H:%M')
   end
+
+  def prices_sum(prices_list)
+    prices_list.sum(&:to_f).round(2)
+  end
 end

lib/reporting/report_template.rb

@@ -88,7 +88,7 @@ def custom_headers
     #   summary_row: proc do |group_key, items, rows|
     #     {
     #       quantity: rows.map(&:quantity).sum(&:to_i),
-    #       price: "#{rows.map(&:price).sum(&:to_f).round(2)} #{currency_symbol}"
+    #       price: "#{prices_sum(rows.map(&:price))} #{currency_symbol}"
     #     }
     #   end,
     #   summary_row_class: "", # by default 'text-bold'

lib/reporting/reports/bulk_coop/allocation.rb

@@ -32,7 +32,7 @@ def rules
               summary_row: proc do |_key, items, rows|
                 line_items = items.flatten
                 {
-                  sum_total: rows.map(&:sum_total).sum(&:to_f).round(2),
+                  sum_total: prices_sum(rows.map(&:sum_total)),
                   total_available: total_available(line_items),
                   unallocated: remainder(line_items),
                   max_quantity_excess: max_quantity_excess(line_items)

lib/reporting/reports/bulk_coop/base.rb

@@ -96,7 +96,7 @@ def remainder(line_items)
         def total_amount(line_items)
           line_items.map { |li|
             scaled_final_weight_volume(li)
-          }.sum(&:to_f).round(2)
+          }.sum(&:to_f).round(3)
         end
 
         def scaled_final_weight_volume(line_item)

lib/reporting/reports/bulk_coop/customer_payments.rb

@@ -21,15 +21,15 @@ def columns
         private
 
         def customer_payments_total_cost(line_items)
-          unique_orders(line_items).map(&:total).sum(&:to_f).round(2)
+          prices_sum(unique_orders(line_items).map(&:total))
         end
 
         def customer_payments_amount_owed(line_items)
-          unique_orders(line_items).map(&:new_outstanding_balance).sum(&:to_f).round(2)
+          prices_sum(unique_orders(line_items).map(&:new_outstanding_balance))
         end
 
         def customer_payments_amount_paid(line_items)
-          unique_orders(line_items).map(&:payment_total).sum(&:to_f).round(2)
+          prices_sum(unique_orders(line_items).map(&:payment_total))
         end
 
         def unique_orders(line_items)

lib/reporting/reports/bulk_coop/supplier_report.rb

@@ -32,7 +32,7 @@ def rules
               summary_row: proc do |_key, items, rows|
                 line_items = items.flatten
                 {
-                  sum_total: rows.map(&:sum_total).sum(&:to_f).round(2),
+                  sum_total: prices_sum(rows.map(&:sum_total)),
                   units_required: units_required(line_items),
                   unallocated: remainder(line_items),
                   max_quantity_excess: max_quantity_excess(line_items)

lib/reporting/reports/customers/base.rb

@@ -33,7 +33,7 @@ def columns
                          },
             shipping_method: proc { |orders| last_completed_order(orders).shipping_method&.name },
             total_orders: proc { |orders| orders.count },
-            total_incl_tax: proc { |orders| orders.map(&:total).sum(&:to_f).round(2) },
+            total_incl_tax: proc { |orders| prices_sum(orders.map(&:total)) },
             last_completed_order_date: proc { |orders| last_completed_order_date(orders) },
           }
         end

lib/reporting/reports/enterprise_fee_summary/enterprise_fees_with_tax_report_by_order.rb

@@ -158,7 +158,7 @@ def rules
         end
 
         def enterprise_fees_sum(order)
-          amount = enterprise_fees(order).map(&:amount).sum(&:to_f).round(2)
+          amount = prices_sum(enterprise_fees(order).map(&:amount))
           apply_voucher_on_amount(order, amount)
         end
 
@@ -183,7 +183,7 @@ def enterprise_fee_tax(order, included: false, added: false)
           query = query.inclusive if included == true
           query = query.additional if added == true
           amount =
-            query.where(adjustable: enterprise_fees(order)).map(&:amount).sum(&:to_f).round(2)
+            prices_sum(query.where(adjustable: enterprise_fees(order)).map(&:amount))
           apply_voucher_on_amount(order, amount)
         end
 

lib/reporting/reports/enterprise_fee_summary/enterprise_fees_with_tax_report_by_producer.rb

@@ -232,7 +232,7 @@ def order_cycle_totals_row
                 line_item.supplier_id == supplier_id
               end
 
-            tax_for_enterprise_fees = rows.map(&:tax).sum(&:to_f).round(2)
+            tax_for_enterprise_fees = prices_sum(rows.map(&:tax))
             total_excl_tax = total_fees_excl_tax(items) + line_items_excl_tax(line_items)
             tax = tax_for_enterprise_fees + tax_for_line_items(line_items)
             {
@@ -280,18 +280,18 @@ def total_fees_excl_tax(items)
         end
 
         def line_items_excl_tax(line_items)
-          cost_of_line_items(line_items) - line_items.map(&:included_tax).sum(&:to_f).round(2)
+          cost_of_line_items(line_items) - prices_sum(line_items.map(&:included_tax))
         end
 
         def cost_of_line_items(line_items)
-          line_items.map(&:amount).sum(&:to_f).round(2)
+          prices_sum(line_items.map(&:amount))
         end
 
         # This query gets called twice for each set of line_items, ideally it would be cached.
         def tax_for_line_items(line_items)
-          line_items.map do |line_item|
+          prices_sum(line_items.map do |line_item|
             line_item.adjustments.eligible.tax.map(&:amount).sum(&:to_f)
-          end.sum(&:to_f).round(2)
+          end)
         end
 
         def included_tax_for_order_ids(order_ids, enterprise_fee_ids)

lib/reporting/reports/orders_and_fulfillment/order_cycle_customer_totals.rb

@@ -23,9 +23,9 @@ def columns
             variant: variant_name,
 
             quantity: proc { |line_items| line_items.map(&:quantity).sum(&:to_i) },
-            item_price: proc { |line_items| line_items.map(&:amount).sum(&:to_f).round(2) },
+            item_price: proc { |line_items| prices_sum(line_items.map(&:amount)) },
             item_fees_price: proc { |line_items|
-              line_items.map(&:amount_with_adjustments).sum(&:to_f).round(2)
+              prices_sum(line_items.map(&:amount_with_adjustments))
             },
             admin_handling_fees: proc { |_line_items| "" },
             ship_price: proc { |_line_items| "" },
@@ -68,7 +68,7 @@ def columns
             order_number: proc { |line_items| line_items.first.order.number },
             date: proc { |line_items| line_items.first.order.completed_at.strftime("%F %T") },
             final_weight_volume: proc { |line_items|
-              line_items.map(&:final_weight_volume).sum(&:to_f).round(2)
+              line_items.map(&:final_weight_volume).sum(&:to_f).round(3)
             },
             shipment_state: proc { |line_items| line_items.first.order.shipment_state },
           }
@@ -129,8 +129,8 @@ def summary_row(order, rows)
           {
             hub: rows.last.hub,
             customer: rows.last.customer,
-            item_price: rows.map(&:item_price).sum(&:to_f).round(2),
-            item_fees_price: rows.map(&:item_fees_price).sum(&:to_f).round(2),
+            item_price: prices_sum(rows.map(&:item_price)),
+            item_fees_price: prices_sum(rows.map(&:item_fees_price)),
             admin_handling_fees: order.admin_and_handling_total,
             ship_price: order.ship_total,
             pay_fee_price: order.payment_fee,