Rename Refund to Return

- better name describes the acutal feature that is returing products not refunding money
- maintain backward compatibtility by transforming deprecated events classes and payloads

Author: dysk

ecommerce/ordering/lib/ordering/commands/add_item_to_return.rb

@@ -0,0 +1,11 @@
+module Ordering
+  class AddItemToReturn < Infra::Command
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+    attribute :product_id, Infra::Types::UUID
+
+    alias aggregate_id return_id
+  end
+
+  AddItemToRefund = AddItemToReturn
+end

ecommerce/ordering/lib/ordering/commands/create_draft_return.rb

@@ -0,0 +1,10 @@
+module Ordering
+  class CreateDraftReturn < Infra::Command
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+
+    alias aggregate_id return_id
+  end
+
+  CreateDraftRefund = CreateDraftReturn
+end

ecommerce/ordering/lib/ordering/commands/remove_item_from_return.rb

@@ -0,0 +1,11 @@
+module Ordering
+  class RemoveItemFromReturn < Infra::Command
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+    attribute :product_id, Infra::Types::UUID
+
+    alias aggregate_id return_id
+  end
+
+  RemoveItemFromRefund = RemoveItemFromReturn
+end

ecommerce/ordering/lib/ordering/events/draft_return_created.rb

@@ -0,0 +1,14 @@
+module Ordering
+  class DraftReturnCreated < Infra::Event
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+    attribute :returnable_products, Infra::Types::Array.of(
+      Infra::Types::Hash.schema(
+        product_id: Infra::Types::UUID,
+        quantity: Infra::Types::Integer
+      )
+    )
+  end
+
+  DraftRefundCreated = DraftReturnCreated
+end

ecommerce/ordering/lib/ordering/events/item_added_to_return.rb

@@ -0,0 +1,9 @@
+module Ordering
+  class ItemAddedToReturn < Infra::Event
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+    attribute :product_id, Infra::Types::UUID
+  end
+
+  ItemAddedToRefund = ItemAddedToReturn
+end

ecommerce/ordering/lib/ordering/events/item_removed_from_return.rb

@@ -0,0 +1,9 @@
+module Ordering
+  class ItemRemovedFromReturn < Infra::Event
+    attribute :return_id, Infra::Types::UUID
+    attribute :order_id, Infra::Types::UUID
+    attribute :product_id, Infra::Types::UUID
+  end
+
+  ItemRemovedFromRefund = ItemRemovedFromReturn
+end

ecommerce/ordering/lib/ordering/return.rb

@@ -0,0 +1,75 @@
+module Ordering
+  class Return
+    include AggregateRoot
+
+    ExceedsOrderQuantityError = Class.new(StandardError)
+    ReturnHaveNotBeenRequestedForThisProductError = Class.new(StandardError)
+
+    def initialize(id)
+      @id = id
+      @return_items = ItemsList.new
+    end
+
+    def create_draft(order_id, returnable_products)
+      apply DraftReturnCreated.new(data: { return_id: @id, order_id: order_id, returnable_products: returnable_products })
+    end
+
+    def add_item(product_id)
+      raise ExceedsOrderQuantityError unless enough_items?(product_id)
+      apply ItemAddedToReturn.new(data: { return_id: @id, order_id: @order_id, product_id: product_id })
+    end
+
+    def remove_item(product_id)
+      raise ReturnHaveNotBeenRequestedForThisProductError unless @return_items.quantity(product_id).positive?
+      apply ItemRemovedFromReturn.new(data: { return_id: @id, order_id: @order_id, product_id: product_id })
+    end
+
+    on DraftReturnCreated do |event|
+      @order_id = event.data[:order_id]
+      @returnable_products = event.data[:returnable_products]
+    end
+
+    on ItemAddedToReturn do |event|
+      @return_items.increase_quantity(event.data[:product_id])
+    end
+
+    on ItemRemovedFromReturn do |event|
+      @return_items.decrease_quantity(event.data[:product_id])
+    end
+
+    private
+
+    def enough_items?(product_id)
+      @return_items.quantity(product_id) < returnable_quantity(product_id)
+    end
+
+    def returnable_quantity(product_id)
+      product = @returnable_products.find { |product| product.fetch(:product_id) == product_id }
+      product.fetch(:quantity)
+    end
+  end
+
+  class ItemsList
+    attr_reader :return_items
+
+    def initialize
+      @return_items = Hash.new(0)
+    end
+
+    def increase_quantity(product_id)
+      return_items[product_id] = quantity(product_id) + 1
+    end
+
+    def decrease_quantity(product_id)
+      return_items[product_id] -= 1
+      return_items.delete(product_id) if quantity(product_id).equal?(0)
+    end
+
+    def quantity(product_id)
+      return_items[product_id]
+    end
+  end
+
+  Refund = Return
+  RefundableProducts = ReturnableProducts if defined?(ReturnableProducts)
+end

ecommerce/ordering/lib/ordering/returnable_products.rb

@@ -0,0 +1,20 @@
+module Ordering
+  class ReturnableProducts
+    def call(event_store, order_id)
+      accepted_event = event_store
+        .read.backward
+        .stream("Pricing::Offer$#{order_id}")
+        .of_type(Pricing::OfferAccepted)
+        .first
+
+      placed_event = event_store
+        .read
+        .stream("Fulfillment::Order$#{order_id}")
+        .first
+
+      accepted_event.data.fetch(:order_lines) if placed_event
+    end
+  end
+
+  RefundableProducts = ReturnableProducts
+end

ecommerce/ordering/lib/ordering/service.rb

@@ -1,47 +1,51 @@
 module Ordering
-  class OnCreateDraftRefund
+  class OnCreateDraftReturn
     def initialize(event_store)
       @repository = Infra::AggregateRootRepository.new(event_store)
       @event_store = event_store
     end
 
     def call(command)
-      @repository.with_aggregate(Refund, command.aggregate_id) do |refund|
-        refund.create_draft(
+      @repository.with_aggregate(Return, command.aggregate_id) do |return_order|
+        return_order.create_draft(
           command.order_id,
-          refundable_products(command.order_id)
+          returnable_products(command.order_id)
           )
       end
     end
 
     private
 
-    def refundable_products(order_id)
-      RefundableProducts.new.call(@event_store, order_id)
+    def returnable_products(order_id)
+      ReturnableProducts.new.call(@event_store, order_id)
     end
   end
 
-  class OnAddItemToRefund
+  class OnAddItemToReturn
     def initialize(event_store)
       @repository = Infra::AggregateRootRepository.new(event_store)
     end
 
     def call(command)
-      @repository.with_aggregate(Refund, command.aggregate_id) do |refund|
-        refund.add_item(command.product_id)
+      @repository.with_aggregate(Return, command.aggregate_id) do |return_order|
+        return_order.add_item(command.product_id)
       end
     end
   end
 
-  class OnRemoveItemFromRefund
+  class OnRemoveItemFromReturn
     def initialize(event_store)
       @repository = Infra::AggregateRootRepository.new(event_store)
     end
 
     def call(command)
-      @repository.with_aggregate(Refund, command.aggregate_id) do |refund|
-        refund.remove_item(command.product_id)
+      @repository.with_aggregate(Return, command.aggregate_id) do |return_order|
+        return_order.remove_item(command.product_id)
       end
     end
   end
+
+  OnCreateDraftRefund = OnCreateDraftReturn
+  OnAddItemToRefund = OnAddItemToReturn
+  OnRemoveItemFromRefund = OnRemoveItemFromReturn
 end

infra/lib/infra/event_store.rb

@@ -1,7 +1,26 @@
 module Infra
   class EventStore < SimpleDelegator
     def self.main
-      new(RailsEventStore::JSONClient.new)
+      require_relative "../../../rails_application/lib/transformations/refund_to_return_event_mapper" rescue nil
+
+      if defined?(Transformations::RefundToReturnEventMapper)
+        mapper = RubyEventStore::Mappers::PipelineMapper.new(
+          RubyEventStore::Mappers::Pipeline.new(
+            Transformations::RefundToReturnEventMapper.new(
+              'Ordering::DraftRefundCreated' => 'Ordering::DraftReturnCreated',
+              'Ordering::ItemAddedToRefund' => 'Ordering::ItemAddedToReturn',
+              'Ordering::ItemRemovedFromRefund' => 'Ordering::ItemRemovedFromReturn'
+            ),
+            RubyEventStore::Mappers::Transformation::DomainEvent.new,
+            RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new,
+            RubyEventStore::Mappers::Transformation::PreserveTypes.new
+          )
+        )
+      else
+        mapper = default_mapper
+      end
+
+      new(RailsEventStore::JSONClient.new(mapper: mapper))
     end
 
     def self.in_memory
@@ -13,9 +32,26 @@ def self.in_memory
     end
 
     def self.in_memory_rails
+      if defined?(Transformations::RefundToReturnEventMapper)
+        mapper = RubyEventStore::Mappers::PipelineMapper.new(
+          RubyEventStore::Mappers::Pipeline.new(
+            Transformations::RefundToReturnEventMapper.new(
+              'Ordering::DraftRefundCreated' => 'Ordering::DraftReturnCreated',
+              'Ordering::ItemAddedToRefund' => 'Ordering::ItemAddedToReturn',
+              'Ordering::ItemRemovedFromRefund' => 'Ordering::ItemRemovedFromReturn'
+            ),
+            RubyEventStore::Mappers::Transformation::DomainEvent.new,
+            RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
+          )
+        )
+      else
+        mapper = default_mapper
+      end
+      
       new(
         RailsEventStore::Client.new(
-          repository: RubyEventStore::InMemoryRepository.new
+          repository: RubyEventStore::InMemoryRepository.new,
+          mapper: mapper
         )
       )
     end
@@ -31,5 +67,16 @@ def link_event_to_stream(event, stream, expected_version: :any)
         expected_version: expected_version
       )
     end
+
+    private
+
+    def self.default_mapper
+      RubyEventStore::Mappers::PipelineMapper.new(
+        RubyEventStore::Mappers::Pipeline.new(
+          RubyEventStore::Mappers::Transformation::DomainEvent.new,
+          RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
+        )
+      )
+    end
   end
 end