Refactor

Author: marlena-b

ecommerce/pricing/lib/pricing.rb

@@ -115,9 +115,7 @@ def call(event_store, command_bus)
         PercentageDiscountReset,
         PercentageDiscountChanged,
         ProductMadeFreeForOrder,
-        FreeProductRemovedFromOrder,
-        TimePromotionDiscountSet,
-        TimePromotionDiscountReset
+        FreeProductRemovedFromOrder
       ])
       event_store.subscribe(CalculateOrderTotalSubAmountsValue, to: [
         PriceItemAdded,
@@ -126,9 +124,7 @@ def call(event_store, command_bus)
         PercentageDiscountReset,
         PercentageDiscountChanged,
         ProductMadeFreeForOrder,
-        FreeProductRemovedFromOrder,
-        TimePromotionDiscountSet,
-        TimePromotionDiscountReset
+        FreeProductRemovedFromOrder
       ])
     end
   end

ecommerce/pricing/lib/pricing/apply_time_promotion.rb

@@ -3,11 +3,13 @@ class ApplyTimePromotion
     def call(event)
       discount = PromotionsCalendar.new(event_store).current_time_promotions_discount
 
-      if discount.exists?
-        command_bus.(SetTimePromotionDiscount.new(order_id: event.data.fetch(:order_id), amount: discount.value))
+      if discount
+        command_bus.(SetTimePromotionDiscount.new(order_id: event.data.fetch(:order_id), amount: discount))
       else
         command_bus.(ResetTimePromotionDiscount.new(order_id: event.data.fetch(:order_id)))
       end
+
+    rescue NotPossibleToAssignDiscountTwice, NotPossibleToResetWithoutDiscount
     end
 
     private

ecommerce/pricing/lib/pricing/discounts.rb

@@ -1,18 +1,10 @@
 module Pricing
   module Discounts
-    class UnacceptableDiscountRange < StandardError
-    end
+    GENERAL_DISCOUNT = "general_discount"
+    TIME_PROMOTION_DISCOUNT = "time_promotion_discount"
 
-    class Discount
-      def self.build(discount)
-        if discount.zero?
-          NoPercentageDiscount.new
-        else
-          PercentageDiscount.new(discount)
-        end
-      end
+    class UnacceptableDiscountRange < StandardError
     end
-
     class PercentageDiscount
       attr_reader :value
 
@@ -37,10 +29,6 @@ def ==(other)
         value == other.value
       end
 
-      def exists?
-        true
-      end
-
       private
 
       def discount(total)
@@ -64,10 +52,6 @@ def value
       def ==(other)
         value == other.value
       end
-
-      def exists?
-        false
-      end
     end
   end
 end

ecommerce/pricing/lib/pricing/events.rb

@@ -34,18 +34,10 @@ class PriceItemValueCalculated < Infra::Event
 
   class PercentageDiscountSet < Infra::Event
     attribute :order_id, Infra::Types::UUID
+    attribute :type, Infra::Types::String
     attribute :amount, Infra::Types::PercentageDiscount
   end
 
-  class TimePromotionDiscountSet < Infra::Event
-    attribute :order_id, Infra::Types::UUID
-    attribute :amount, Infra::Types::PercentageDiscount
-  end
-
-  class TimePromotionDiscountReset < Infra::Event
-    attribute :order_id, Infra::Types::UUID
-  end
-
   class PriceItemAdded < Infra::Event
     attribute :order_id, Infra::Types::UUID
     attribute :product_id, Infra::Types::UUID
@@ -58,10 +50,12 @@ class PriceItemRemoved < Infra::Event
 
   class PercentageDiscountReset < Infra::Event
     attribute :order_id, Infra::Types::UUID
+    attribute :type, Infra::Types::String
   end
 
   class PercentageDiscountChanged < Infra::Event
     attribute :order_id, Infra::Types::UUID
+    attribute :type, Infra::Types::String
     attribute :amount, Infra::Types::Price
   end
 

ecommerce/pricing/lib/pricing/offer.rb

@@ -5,8 +5,7 @@ class Offer
     def initialize(id)
       @id = id
       @list = List.new
-      @discount = Discounts::NoPercentageDiscount.new
-      @time_promotion_discount = Discounts::NoPercentageDiscount.new
+      @discounts = {}
     end
 
     def add_item(product_id)
@@ -27,50 +26,34 @@ def remove_item(product_id)
       )
     end
 
-    def apply_discount(discount)
-      raise NotPossibleToAssignDiscountTwice if @discount.exists?
+    def apply_discount(type, discount)
+      raise NotPossibleToAssignDiscountTwice if @discounts.include?(type)
       apply PercentageDiscountSet.new(
         data: {
           order_id: @id,
+          type: type,
           amount: discount.value
         }
       )
     end
 
-    def apply_time_promotion_discount(time_promotion)
-      return if time_promotion == @time_promotion_discount
-      apply TimePromotionDiscountSet.new(
-        data: {
-          order_id: @id,
-          amount: time_promotion.value
-        }
-      )
-    end
-
-    def reset_time_promotion_discount
-      return unless @time_promotion_discount.exists?
-      apply TimePromotionDiscountReset.new(
-        data: {
-          order_id: @id
-        }
-      )
-    end
-
-    def change_discount(discount)
-      raise NotPossibleToChangeDiscount unless @discount.exists?
+    def change_discount(type, discount)
+      raise NotPossibleToChangeDiscount unless @discounts.include?(type)
       apply PercentageDiscountChanged.new(
         data: {
           order_id: @id,
+          type: type,
           amount: discount.value
         }
       )
     end
 
-    def reset_discount
-      raise NotPossibleToResetWithoutDiscount unless @discount.exists?
+    def reset_discount(type)
+      raise NotPossibleToResetWithoutDiscount unless @discounts.include?(type)
       apply PercentageDiscountReset.new(
         data: {
-          order_id: @id
+          order_id: @id,
+          type: type
         }
       )
     end
@@ -97,22 +80,22 @@ def remove_free_product(order_id, product_id)
 
     def calculate_total_value(pricing_catalog)
       total_value = @list.base_sum(pricing_catalog)
+      discounted_value = @discounts.values.inject(Discounts::NoPercentageDiscount.new, :add).apply(total_value)
 
-      discounted_value = @discount.add(@time_promotion_discount).apply(total_value)
       apply(
         OrderTotalValueCalculated.new(
           data: {
             order_id: @id,
             total_amount: total_value,
-            discounted_amount: discounted_value
+            discounted_amount: discounted_value || total_value
           }
         )
       )
     end
 
     def calculate_sub_amounts(pricing_catalog)
       sub_amounts_total = @list.sub_amounts_total(pricing_catalog)
-      sub_discounts = calculate_total_sub_discounts(pricing_catalog, @time_promotion_discount)
+      sub_discounts = calculate_total_sub_discounts(pricing_catalog)
 
       products = @list.products
       quantities = @list.quantities
@@ -158,23 +141,15 @@ def use_coupon(coupon_id, discount)
     end
 
     on PercentageDiscountSet do |event|
-      @discount = Discounts::PercentageDiscount.new(event.data.fetch(:amount))
+      @discounts[event.data.fetch(:type)] = Discounts::PercentageDiscount.new(event.data.fetch(:amount))
     end
 
     on PercentageDiscountChanged do |event|
-      @discount = Discounts::PercentageDiscount.new(event.data.fetch(:amount))
-    end
-
-    on TimePromotionDiscountSet do |event|
-      @time_promotion_discount = Discounts::PercentageDiscount.new(event.data.fetch(:amount))
-    end
-
-    on TimePromotionDiscountReset do |event|
-      @time_promotion_discount = Discounts::NoPercentageDiscount.new
+      @discounts[event.data.fetch(:type)] = Discounts::PercentageDiscount.new(event.data.fetch(:amount))
     end
 
     on PercentageDiscountReset do |event|
-      @discount = Discounts::NoPercentageDiscount.new
+      @discounts.delete(event.data.fetch(:type))
     end
 
     on ProductMadeFreeForOrder do |event|
@@ -185,8 +160,8 @@ def use_coupon(coupon_id, discount)
       @list.replace(FreeProduct, Product, event.data.fetch(:product_id))
     end
 
-    def calculate_total_sub_discounts(pricing_catalog, time_promotions_discount)
-      @list.sub_discounts(pricing_catalog, time_promotions_discount, @discount)
+    def calculate_total_sub_discounts(pricing_catalog)
+      @list.sub_discounts(pricing_catalog, @discounts)
     end
 
     on CouponUsed do |event|
@@ -237,10 +212,10 @@ def sub_amounts_total(pricing_catalog)
         @products_quantities.map { |product, quantity| quantity * pricing_catalog.price_for(product) }
       end
 
-      def sub_discounts(pricing_catalog, time_promotions_discount, discount)
+      def sub_discounts(pricing_catalog, discounts)
         @products_quantities.map do |product, quantity|
           catalog_price_for_single = pricing_catalog.price_for(product)
-          with_total_discount_single = discount.add(time_promotions_discount).apply(catalog_price_for_single)
+          with_total_discount_single = discounts.values.inject(Discounts::NoPercentageDiscount.new, :add).apply(catalog_price_for_single)
           quantity * (catalog_price_for_single - with_total_discount_single)
         end
       end

ecommerce/pricing/lib/pricing/promotions_calendar.rb

@@ -5,9 +5,7 @@ def initialize(event_store)
     end
 
     def current_time_promotions_discount
-      Discounts::Discount.build(
-        PromotionsStrategy.biggest_for_client(all_promotions)
-      )
+      PromotionsStrategy.biggest_for_client(all_promotions)
     end
 
     private
@@ -23,7 +21,7 @@ class PromotionsStrategy
       def self.biggest_for_client(promotions)
         promotions
           .filter { |promotion| promotion.running?(Time.current) }
-          .map { |promotion| promotion.discount }.max || 0
+          .map { |promotion| promotion.discount }.max
       end
     end
 

ecommerce/pricing/lib/pricing/services.rb

@@ -21,7 +21,7 @@ def initialize(event_store)
 
     def call(cmd)
       @repository.with_aggregate(Offer, cmd.aggregate_id) do |order|
-        order.apply_discount(Discounts::PercentageDiscount.new(cmd.amount))
+        order.apply_discount(Discounts::GENERAL_DISCOUNT, Discounts::PercentageDiscount.new(cmd.amount))
       end
     end
   end
@@ -33,7 +33,7 @@ def initialize(event_store)
 
     def call(cmd)
       @repository.with_aggregate(Offer, cmd.aggregate_id) do |order|
-        order.reset_discount
+        order.reset_discount(Discounts::GENERAL_DISCOUNT)
       end
     end
   end
@@ -45,7 +45,7 @@ def initialize(event_store)
 
     def call(cmd)
       @repository.with_aggregate(Offer, cmd.aggregate_id) do |order|
-        order.change_discount(Discounts::PercentageDiscount.new(cmd.amount))
+        order.change_discount(Discounts::GENERAL_DISCOUNT, Discounts::PercentageDiscount.new(cmd.amount))
       end
     end
   end
@@ -57,7 +57,7 @@ def initialize(event_store)
 
     def call(cmd)
       @repository.with_aggregate(Offer, cmd.aggregate_id) do |order|
-        order.apply_time_promotion_discount(Discounts::PercentageDiscount.new(cmd.amount))
+        order.apply_discount(Discounts::TIME_PROMOTION_DISCOUNT, Discounts::PercentageDiscount.new(cmd.amount))
       end
     end
   end
@@ -69,7 +69,7 @@ def initialize(event_store)
 
     def call(cmd)
       @repository.with_aggregate(Offer, cmd.aggregate_id) do |order|
-        order.reset_time_promotion_discount
+        order.reset_discount(Discounts::TIME_PROMOTION_DISCOUNT)
       end
     end
   end

ecommerce/pricing/test/apply_time_promotion_test.rb

@@ -12,18 +12,21 @@ def test_applies_biggest_time_promotion_discount
       create_active_time_promotion(50)
       create_active_time_promotion(30)
 
-      assert_events_contain(stream_name(order_id), time_promotion_discount_set_event(order_id, 50)) do
-          Pricing::ApplyTimePromotion.new.call(item_added_to_basket_event(order_id, product_id))
+      assert_events_contain(stream_name(order_id), percentage_discount_set_event(order_id, 50)) do
+        Pricing::ApplyTimePromotion.new.call(item_added_to_basket_event(order_id, product_id))
       end
     end
 
     def test_resets_time_promotion_discount
       order_id = SecureRandom.uuid
       product_id = SecureRandom.uuid
+      create_active_time_promotion(50)
       set_time_promotion_discount(order_id, 50)
 
-      assert_events_contain(stream_name(order_id), time_promotion_discount_reset_event(order_id)) do
+      Timecop.travel(1.minute.from_now) do
+        assert_events_contain(stream_name(order_id), percentage_discount_reset_event(order_id)) do
           Pricing::ApplyTimePromotion.new.call(item_added_to_basket_event(order_id, product_id))
+        end
       end
     end
 
@@ -63,22 +66,24 @@ def item_added_to_basket_event(order_id, product_id)
     end
 
     def set_time_promotion_discount(order_id, discount)
-      run_command(SetTimePromotionDiscount.new(order_id: order_id, amount: 50))
+      run_command(SetTimePromotionDiscount.new(order_id: order_id, amount: discount))
     end
 
-    def time_promotion_discount_set_event(order_id, amount)
-      TimePromotionDiscountSet.new(
+    def percentage_discount_set_event(order_id, amount)
+      PercentageDiscountSet.new(
         data: {
           order_id: order_id,
+          type: Pricing::Discounts::TIME_PROMOTION_DISCOUNT,
           amount: amount
         }
       )
     end
 
-    def time_promotion_discount_reset_event(order_id)
-      TimePromotionDiscountReset.new(
+    def percentage_discount_reset_event(order_id)
+      PercentageDiscountReset.new(
         data: {
-          order_id: order_id
+          order_id: order_id,
+          type: Pricing::Discounts::TIME_PROMOTION_DISCOUNT
         }
       )
     end

ecommerce/pricing/test/discounts_test.rb

@@ -91,10 +91,6 @@ def test_is_not_equal_to_another_discount
 
         refute_equal(first_discount, second_discount)
       end
-
-      def test_exists_returns_false
-        assert_equal false, NoPercentageDiscount.new.exists?
-      end
     end
   end
 end