An experiment with TotalOrderValueUpdated (to be renamed) to bring items too

This for sure simplifies InvoiceGeneration process a lot.
But it might introduce some coupling to this one "god" summary event.

Author: andrzejkrzywda

rails_application/app/processes/processes/invoice_generation.rb

@@ -10,11 +10,7 @@ def initialize(event_store, command_bus)
     end
 
     subscribes_to(
-      Pricing::PriceItemAdded,
-      Pricing::PriceItemRemoved,
-      Pricing::PercentageDiscountSet,
-      Pricing::PercentageDiscountChanged,
-      Pricing::PercentageDiscountRemoved,
+      Processes::TotalOrderValueUpdated,
       Fulfillment::OrderRegistered
     )
 
@@ -25,14 +21,8 @@ def act
     private
 
     def create_invoice_items_for_all_products
-      product_totals.each do |product_id, quantity, amount|
-        create_invoice_items_for_product(product_id, quantity, amount)
-      end
-    end
-
-    def product_totals
-      state.sub_amounts_total.map do |product_id, amounts|
-        [product_id, amounts.fetch(:quantity), amounts.fetch(:amount)]
+      state.items.each do |item|
+        create_invoice_items_for_product(item.fetch(:product_id), item.fetch(:quantity), item.fetch(:amount))
       end
     end
 
@@ -43,16 +33,8 @@ def fetch_id(event)
     def apply(event)
       @order_id = event.data.fetch(:order_id)
       case event
-      when Pricing::PriceItemAdded
-        state.add_line(event.data.fetch(:product_id), event.data.fetch(:base_price), event.data.fetch(:price))
-      when Pricing::PriceItemRemoved
-        state.remove_line(event.data.fetch(:product_id))
-      when Pricing::PercentageDiscountSet
-        state.set_discount(event.data.fetch(:type), event.data.fetch(:amount))
-      when Pricing::PercentageDiscountChanged
-        state.set_discount(event.data.fetch(:type), event.data.fetch(:amount))
-      when Pricing::PercentageDiscountRemoved
-        state.remove_discount(event.data.fetch(:type))
+      when TotalOrderValueUpdated
+        state.set_items(event.data.fetch(:items))
       when Fulfillment::OrderRegistered
         state.mark_placed
       end
@@ -76,29 +58,13 @@ def create_invoice_items_for_product(product_id, quantity, discounted_amount)
 
   end
 
-  Invoice = Data.define(:lines, :discounts, :order_placed) do
-    def initialize(lines: [], discounts: [], order_placed: false)
-      super(lines: lines.freeze, discounts: discounts.freeze, order_placed: order_placed)
-    end
-
-    def add_line(product_id, base_price, price)
-      with(lines: lines + [{ product_id:, base_price:, price: }])
-    end
-
-    def remove_line(product_id)
-      with(lines: lines.dup.tap { |lines| lines.delete_at(index_of_first_line_with(product_id)) })
-    end
-
-    def index_of_first_line_with(product_id)
-      lines.find_index { |line| line.fetch(:product_id) == product_id }
-    end
-
-    def set_discount(type, amount)
-      with_discounts_applied(discounts.reject { |d| d.fetch(:type) == type } + [{ type:, amount: }])
+  Invoice = Data.define(:items, :order_placed) do
+    def initialize(items: [], order_placed: false)
+      super(items: items.freeze, order_placed: order_placed)
     end
 
-    def remove_discount(type)
-      with_discounts_applied(discounts.reject { |d| d.fetch(:type) == type })
+    def set_items(new_items)
+      with(items: new_items)
     end
 
     def mark_placed
@@ -108,50 +74,6 @@ def mark_placed
     def placed?
       order_placed
     end
-
-    def apply_discounts_to_lines
-      with(lines: lines.map { |line| apply_discount_to_line(line) })
-    end
-
-    def apply_discount_to_line(line)
-      line.merge(price: line.fetch(:base_price) * discount_multiplier)
-    end
-
-    def discount_multiplier
-      1 - (final_discount_percentage / 100.0)
-    end
-
-    def sub_amounts_total
-      lines.each_with_object({}) do |line, memo|
-        product_id = line.fetch(:product_id)
-        memo[product_id] ||= { base_amount: 0, amount: 0, quantity: 0 }
-        memo[product_id][:base_amount] += line.fetch(:base_price)
-        memo[product_id][:amount] += line.fetch(:price)
-        memo[product_id][:quantity] += 1
-      end
-    end
-
-    private
-
-    def with_discounts_applied(new_discounts)
-      with(discounts: new_discounts).apply_discounts_to_lines
-    end
-
-    def subtotal
-      lines.sum { |line| line.fetch(:price) }
-    end
-
-    def total_discount_percentage
-      discounts.sum { |discount| discount.fetch(:amount) }
-    end
-
-    def final_discount_percentage
-      [total_discount_percentage, 100].min
-    end
-
-    def discounted_value
-      subtotal * (1 - final_discount_percentage / 100.0)
-    end
   end
 
 end

rails_application/app/processes/processes/total_order_value.rb

@@ -11,7 +11,7 @@ class TotalOrderValue
     )
 
     def act
-      publish_total_order_value(state.subtotal, state.discounted_value)
+      publish_total_order_value(state.subtotal, state.discounted_value, state.per_product_discounted_totals)
     end
 
     def apply(event)
@@ -34,12 +34,13 @@ def apply(event)
 
     private
 
-    def publish_total_order_value(total_amount, discounted_amount)
+    def publish_total_order_value(total_amount, discounted_amount, items)
       event_store.publish(
-        TotalOrderValueUpdated.new(data: { 
-          total_amount: total_amount, 
+        TotalOrderValueUpdated.new(data: {
+          total_amount: total_amount,
           discounted_amount: discounted_amount,
-          order_id: @order_id 
+          items: items,
+          order_id: @order_id
         }),
         stream_name: "Processes::TotalOrderValue$#{@order_id}"
       )
@@ -105,6 +106,20 @@ def final_discount_percentage
     def discounted_value
       subtotal * (1 - final_discount_percentage / 100.0)
     end
+
+    def discount_multiplier
+      1 - (final_discount_percentage / 100.0)
+    end
+
+    def per_product_discounted_totals
+      grouped = lines.group_by { |line| line.fetch(:product_id) }
+      grouped.map do |product_id, lines_for_product|
+        quantity = lines_for_product.size
+        base_amount = lines_for_product.sum { |line| line.fetch(:price) }
+        amount = base_amount * discount_multiplier
+        { product_id: product_id, quantity: quantity, amount: amount }
+      end
+    end
   end
 
-end
+end

rails_application/test/client_orders/order_paid_test.rb

@@ -19,7 +19,8 @@ def test_order_confirmed
           data: {
             order_id: order_id,
             discounted_amount: 30,
-            total_amount: 30
+            total_amount: 30,
+            items: [ { product_id: product_id, quantity: 1, amount: 30 } ]
           }
         )
       )

rails_application/test/client_orders/update_order_total_value_test.rb

@@ -12,15 +12,15 @@ def test_order_created_has_draft_state
       customer_registered(customer_id)
       prepare_product(product_id)
 
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [] }))
 
       order = ClientOrders::Order.find_by(order_uid: order_id)
       assert_equal "Draft", order.state
     end
 
     def test_broadcasts
       order_id = SecureRandom.uuid
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [] }))
 
       assert_broadcast_on(
         "client_orders_#{order_id}",

rails_application/test/client_orders/update_paid_orders_summary_test.rb

@@ -4,6 +4,11 @@ module ClientOrders
   class UpdatePaidOrdersSummaryTest < InMemoryTestCase
     cover "ClientOrders*"
 
+    def setup
+      super
+      @order_products = Hash.new { |h, k| h[k] = [] }
+    end
+
     def test_update_orders_summary
       customer_id = SecureRandom.uuid
       other_customer_id = SecureRandom.uuid
@@ -56,16 +61,22 @@ def set_price_to_product(product_id, price)
     end
 
     def add_item_to_basket(order_id, product_id, price)
+      @order_products[order_id] << product_id
       run_command(Pricing::AddPriceItem.new(order_id: order_id, product_id: product_id, price: price))
     end
 
     def confirm_order(customer_id, order_id, total_amount)
+      grouped = @order_products[order_id].group_by { |pid| pid }
+      items = grouped.map do |pid, list|
+        { product_id: pid, quantity: list.size, amount: total_amount }
+      end
       event_store.publish(
         Processes::TotalOrderValueUpdated.new(
           data: {
             order_id: order_id,
             discounted_amount: total_amount,
-            total_amount: total_amount
+            total_amount: total_amount,
+            items: items
           }
         )
       )

rails_application/test/customers/update_paid_orders_summary_test.rb

@@ -4,6 +4,11 @@ module Customers
   class UpdatePaidOrdersSummaryTest < InMemoryTestCase
     cover "Customers"
 
+    def setup
+      super
+      @order_products = Hash.new { |h, k| h[k] = [] }
+    end
+
     def test_update_orders_summary
       customer_id = SecureRandom.uuid
       other_customer_id = SecureRandom.uuid
@@ -55,16 +60,22 @@ def set_vat_rate_to_product(product_id)
     end
 
     def add_item_to_basket(order_id, product_id, price)
+      @order_products[order_id] << product_id
       run_command(Pricing::AddPriceItem.new(order_id: order_id, product_id: product_id, price: price))
     end
 
     def confirm_order(customer_id, order_id, total_amount)
+      grouped = @order_products[order_id].group_by { |pid| pid }
+      items = grouped.map do |pid, list|
+        { product_id: pid, quantity: list.size, amount: total_amount }
+      end
       event_store.publish(
         Processes::TotalOrderValueUpdated.new(
           data: {
             order_id: order_id,
             discounted_amount: total_amount,
-            total_amount: total_amount
+            total_amount: total_amount,
+            items: items
           }
         )
       )

rails_application/test/orders/broadcast_test.rb

@@ -177,7 +177,8 @@ def test_broadcast_update_order_value
           data: {
             order_id: order_1_id,
             discounted_amount: 30,
-            total_amount: 30
+            total_amount: 30,
+            items: [ { product_id: product_id, quantity: 2, amount: 30 } ]
           }
         )
       )
@@ -189,7 +190,8 @@ def test_broadcast_update_order_value
           data: {
             order_id: order_id,
             discounted_amount: 30,
-            total_amount: 30
+            total_amount: 30,
+            items: [ { product_id: product_id, quantity: 1, amount: 30 } ]
           }
         )
       )

rails_application/test/orders/order_paid_test.rb

@@ -37,7 +37,7 @@ def test_order_confirmed
         Crm::CustomerAssignedToOrder.new(data: { customer_id: customer_id, order_id: order_id })
       )
 
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [ { product_id: product_id, quantity: 1, amount: 10 } ] }))
       order_confirmed = Fulfillment::OrderConfirmed.new(
         data: {
           order_id: order_id

rails_application/test/orders/update_order_total_value_test.rb

@@ -11,7 +11,7 @@ def test_order_created_has_draft_state
       customer_registered(customer_id)
       prepare_product(product_id)
 
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [] }))
 
       order = Orders::Order.find_by(uid: order_id)
       assert_equal "Draft", order.state
@@ -25,8 +25,8 @@ def test_newest_event_is_always_applied
       prepare_product(product_id)
       item_added_to_basket(order_id, product_id)
 
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 }, metadata: { timestamp: Time.current }))
-      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 10, total_amount: 20 }, metadata: { timestamp: 1.minute.ago }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [] }, metadata: { timestamp: Time.current }))
+      event_store.publish(Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 10, total_amount: 20, items: [] }, metadata: { timestamp: 1.minute.ago }))
 
       order = Orders::Order.find_by(uid: order_id)
       assert_equal 10, order.total_value
@@ -47,7 +47,7 @@ def test_stream
     private
 
     def total_order_value_updated(order_id)
-      Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10 })
+      Processes::TotalOrderValueUpdated.new(data: { order_id: order_id, discounted_amount: 0, total_amount: 10, items: [] })
     end
 
     def item_added_to_basket(order_id, product_id)