move Orderign::Order expiration to Pricing::Offer expiration

Author: porbas

ecommerce/pricing/lib/pricing.rb

@@ -90,6 +90,10 @@ def call(event_store, command_bus)
         RejectOffer,
         OnRejectOffer.new(event_store)
       )
+      command_bus.register(
+        ExpireOffer,
+        OnExpireOffer.new(event_store)
+      )
       command_bus.register(
         SetTimePromotionDiscount,
         SetTimePromotionDiscountHandler.new(event_store)

ecommerce/pricing/lib/pricing/commands.rb

@@ -104,4 +104,10 @@ class RejectOffer < Infra::Command
 
     alias aggregate_id order_id
   end
+
+  class ExpireOffer < Infra::Command
+    attribute :order_id, Infra::Types::UUID
+
+    alias aggregate_id order_id
+  end
 end

ecommerce/pricing/lib/pricing/events.rb

@@ -87,4 +87,8 @@ class OfferAccepted < Infra::Event
   class OfferRejected < Infra::Event
     attribute :order_id, Infra::Types::UUID
   end
+
+  class OfferExpired < Infra::Event
+    attribute :order_id, Infra::Types::UUID
+  end
 end

ecommerce/pricing/lib/pricing/offer.rb

@@ -6,11 +6,11 @@ def initialize(id)
       @id = id
       @items = []
       @discounts = []
-      @accepted = false
+      @state = :draft
     end
 
     def add_item(product_id, pricing_policy)
-      fail_if_accepted
+      fail_unless_draft
       apply_discounts_to_pricing_policy(pricing_policy)
       items = pricing_policy.apply(@items, product_id)
       apply PriceItemAdded.new(
@@ -24,7 +24,7 @@ def add_item(product_id, pricing_policy)
     end
 
     def remove_item(product_id, catalog_price)
-      fail_if_accepted
+      fail_unless_draft
       item = @items.find { |item| item.product_id == product_id && item.catalog_price == catalog_price }
       return unless item
       apply PriceItemRemoved.new(
@@ -38,7 +38,7 @@ def remove_item(product_id, catalog_price)
     end
 
     def apply_discount(discount, pricing_policy)
-      fail_if_accepted
+      fail_unless_draft
       raise NotPossibleToAssignDiscountTwice if discount_exists?(discount.type)
       apply PercentageDiscountSet.new(
         data: {
@@ -52,7 +52,7 @@ def apply_discount(discount, pricing_policy)
     end
 
     def change_discount(discount, pricing_policy)
-      fail_if_accepted
+      fail_unless_draft
       raise NotPossibleToChangeDiscount unless discount_exists?(discount.type)
       apply PercentageDiscountChanged.new(
         data: {
@@ -66,7 +66,7 @@ def change_discount(discount, pricing_policy)
     end
 
     def remove_discount(type, pricing_policy)
-      fail_if_accepted
+      fail_unless_draft
       raise NotPossibleToRemoveWithoutDiscount unless discount_exists?(type)
       apply PercentageDiscountRemoved.new(
         data: {
@@ -99,7 +99,7 @@ def remove_free_product(order_id, product_id)
     end
 
     def use_coupon(coupon_id, discount)
-      fail_if_accepted
+      fail_unless_draft
       apply CouponUsed.new(
         data: {
           order_id: @id,
@@ -110,6 +110,7 @@ def use_coupon(coupon_id, discount)
     end
 
     def accept
+      raise CantAcceptEmptyOffer if @items.empty?
       apply OfferAccepted.new(
         data: {
           order_id: @id,
@@ -126,14 +127,20 @@ def accept
     end
 
     def reject
-      raise OnlyAcceptedOfferCanBeRejected unless @accepted
+      raise OnlyAcceptedOfferCanBeRejected unless accepted?
       apply OfferRejected.new(data: { order_id: @id })
     end
 
+    def expire
+      raise OnlyDraftOfferCanBeExpired unless draft?
+      apply OfferExpired.new(data: { order_id: @id })
+    end
+
     private
 
-    def fail_if_accepted
-      raise CantModifyAcceptedOffer if @accepted
+    def fail_unless_draft
+      raise CantModifyAcceptedOffer if accepted?
+      raise CantModifyExpiredOffer if expired?
     end
 
     def apply_discounts_to_pricing_policy(pricing_policy)
@@ -196,17 +203,25 @@ def recalculate_prices(pricing_policy)
     end
 
     on OfferAccepted do |_|
-      @accepted = true
+      @state = :accepted
     end
 
     on OfferRejected do |_|
-      @accepted = false
+      @state = :draft
+    end
+
+    on OfferExpired do |_|
+      @state = :expired
     end
 
     def discount_exists?(type)
       @discounts.find { |discount| discount.type == type }
     end
 
+    def draft? = @state == :draft
+    def accepted? = @state == :accepted
+    def expired? = @state == :expired
+
     ItemPrice = Data.define(:product_id, :catalog_price, :price)
 
     class List

ecommerce/pricing/lib/pricing/services.rb

@@ -14,12 +14,21 @@ class FreeProductAlreadyMade < StandardError
   class FreeProductNotExists < StandardError
   end
 
+  class CantAcceptEmptyOffer < StandardError
+  end
+
   class CantModifyAcceptedOffer < StandardError
   end
 
+  class CantModifyExpiredOffer < StandardError
+  end
+
   class OnlyAcceptedOfferCanBeRejected < StandardError
   end
 
+  class OnlyDraftOfferCanBeExpired < StandardError
+  end
+
   class SetPercentageDiscountHandler
     def initialize(event_store)
       @repository = Infra::AggregateRootRepository.new(event_store)
@@ -231,4 +240,16 @@ def call(command)
       end
     end
   end
+
+  class OnExpireOffer
+    def initialize(event_store)
+      @repository = Infra::AggregateRootRepository.new(event_store)
+    end
+
+    def call(command)
+      @repository.with_aggregate(Offer, command.aggregate_id) do |order|
+        order.expire
+      end
+    end
+  end
 end

rails_application/app/controllers/orders_controller.rb

@@ -92,7 +92,7 @@ def create
   def expire
     Orders::Order
       .where(state: "Draft")
-      .find_each { |order| command_bus.(Ordering::SetOrderAsExpired.new(order_id: order.uid)) }
+      .find_each { |order| command_bus.(Pricing::ExpireOffer.new(order_id: order.uid)) }
     redirect_to root_path
   end
 

rails_application/app/read_models/client_orders/configuration.rb

@@ -41,7 +41,7 @@ class Product < ApplicationRecord
 
   class Configuration
     def call(event_store)
-      event_store.subscribe(OrderHandlers::ExpireOrder, to: [Ordering::OrderExpired])
+      event_store.subscribe(OrderHandlers::ExpireOrder, to: [Pricing::OfferExpired])
       event_store.subscribe(OrderHandlers::CancelOrder, to: [Fulfillment::OrderCancelled])
       event_store.subscribe(OrderHandlers::SubmitOrder, to: [Fulfillment::OrderRegistered])
       event_store.subscribe(OrderHandlers::ConfirmOrder, to: [Fulfillment::OrderConfirmed])

rails_application/app/read_models/orders/configuration.rb

@@ -68,19 +68,19 @@ def call(event_store)
       event_store.subscribe(CreateCustomer.new, to: [Crm::CustomerRegistered])
       event_store.subscribe(AssignCustomerToOrder.new, to: [Crm::CustomerAssignedToOrder])
       event_store.subscribe(SubmitOrder.new, to: [Fulfillment::OrderRegistered])
-      event_store.subscribe(ExpireOrder.new, to: [Ordering::OrderExpired])
+      event_store.subscribe(ExpireOrder.new, to: [Pricing::OfferExpired])
       event_store.subscribe(ConfirmOrder.new, to: [Fulfillment::OrderConfirmed])
       event_store.subscribe(CancelOrder.new, to: [Fulfillment::OrderCancelled])
       event_store.subscribe(UpdateTimePromotionDiscountValue.new, to: [Pricing::PercentageDiscountSet])
       event_store.subscribe(RemoveTimePromotionDiscount.new, to: [Pricing::PercentageDiscountRemoved])
 
       subscribe(
         ->(event) { broadcast_order_state_change(event.data.fetch(:order_id), 'Submitted') },
-        [Ordering::OrderPlaced]
+        [Fulfillment::OrderRegistered]
       )
       subscribe(
         ->(event) { broadcast_order_state_change(event.data.fetch(:order_id), "Expired") },
-        [Ordering::OrderExpired]
+        [Pricing::OfferExpired]
       )
       subscribe(
         ->(event) { broadcast_order_state_change(event.data.fetch(:order_id), "Paid") },

rails_application/test/orders/order_expired_test.rb

@@ -26,7 +26,6 @@ def test_expire_created_order
       run_command(Pricing::SetPrice.new(product_id: product_id, price: 39))
 
       order_id = SecureRandom.uuid
-      order_number = Ordering::FakeNumberGenerator::FAKE_NUMBER
       event_store.publish(
         Pricing::PriceItemAdded.new(
           data: {
@@ -37,18 +36,8 @@ def test_expire_created_order
           }
         )
       )
-      event_store.publish(
-        Ordering::OrderPlaced.new(
-          data: {
-            order_id: order_id,
-            order_number: order_number,
-            customer_id: customer_id,
-            order_lines: { product_id => 1 }
-          }
-        )
-      )
 
-      order_expired = Ordering::OrderExpired.new(data: { order_id: order_id })
+      order_expired = Pricing::OfferExpired.new(data: { order_id: order_id })
       event_store.publish(order_expired)
 
       assert_equal(Order.count, 1)