solidus_core 2.1.1 → 2.2.0.beta1

data/app/models/spree/order/checkout.rb

@@ -2,328 +2,242 @@ module Spree
   class Order < Spree::Base
     module Checkout
       def self.included(klass)
-        klass.class_eval do
-          class_attribute :next_event_transitions
-          class_attribute :previous_states
-          class_attribute :checkout_flow
-          class_attribute :checkout_steps
-          class_attribute :removed_transitions
-
-          def self.checkout_flow(&block)
-            if block_given?
-              @checkout_flow = block
-              define_state_machine!
-            else
-              @checkout_flow
-            end
-          end
-
-          def self.define_state_machine!
-            self.checkout_steps = {}
-            self.next_event_transitions = []
-            self.previous_states = [:cart]
-            self.removed_transitions = []
-
-            # Build the checkout flow using the checkout_flow defined either
-            # within the Order class, or a decorator for that class.
-            #
-            # This method may be called multiple times depending on if the
-            # checkout_flow is re-defined in a decorator or not.
-            instance_eval(&checkout_flow)
-
-            klass = self
-
-            # To avoid multiple occurrences of the same transition being defined
-            # On first definition, state_machines will not be defined
-            state_machines.clear if respond_to?(:state_machines)
-            state_machine :state, initial: :cart, use_transactions: false do
-              klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
-
-              # Persist the state on the order
-              after_transition do |order, transition|
-                order.state = order.state
-                order.state_changes.create(
-                  previous_state: transition.from,
-                  next_state:     transition.to,
-                  name:           'order',
-                  user_id:        order.user_id
-                )
-                order.save
-              end
-
-              event :cancel do
-                transition to: :canceled, if: :allow_cancel?
-              end
-
-              event :return do
-                transition to: :returned, from: [:returned, :complete, :awaiting_return, :canceled], if: :all_inventory_units_returned?
-              end
+        klass.extend ClassMethods
+      end
 
-              event :resume do
-                transition to: :resumed, from: :canceled, if: :canceled?
-              end
+      module ClassMethods
+        attr_accessor :next_event_transitions
+        attr_accessor :previous_states
+        attr_accessor :checkout_steps
+        attr_accessor :removed_transitions
 
-              event :authorize_return do
-                transition to: :awaiting_return
-              end
+        def checkout_flow(&block)
+          if block_given?
+            @checkout_flow = block
+            define_state_machine!
+          else
+            @checkout_flow
+          end
+        end
 
-              event :complete do
-                transition to: :complete, from: :confirm
-              end
+        def define_state_machine!
+          self.checkout_steps = {}
+          self.next_event_transitions = []
+          self.previous_states = [:cart]
+          self.removed_transitions = []
 
-              if states[:payment]
-                event :payment_failed do
-                  transition to: :payment, from: :confirm
-                end
+          # Build the checkout flow using the checkout_flow defined either
+          # within the Order class, or a decorator for that class.
+          #
+          # This method may be called multiple times depending on if the
+          # checkout_flow is re-defined in a decorator or not.
+          instance_eval(&checkout_flow)
+
+          klass = self
+
+          # To avoid multiple occurrences of the same transition being defined
+          # On first definition, state_machines will not be defined
+          state_machines.clear if respond_to?(:state_machines)
+          state_machine :state, initial: :cart, use_transactions: false do
+            klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
+
+            # Persist the state on the order
+            after_transition do |order, transition|
+              order.state = order.state
+              order.state_changes.create(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'order',
+                user_id:        order.user_id
+              )
+              order.save
+            end
 
-                after_transition to: :complete, do: :add_payment_sources_to_wallet
-                before_transition to: :payment, do: :set_shipments_cost
-                before_transition to: :payment, do: :assign_default_credit_card
+            event :cancel do
+              transition to: :canceled, if: :allow_cancel?
+            end
 
-                before_transition to: :confirm, do: :add_store_credit_payments
+            event :return do
+              transition to: :returned, from: [:returned, :complete, :awaiting_return, :canceled], if: :all_inventory_units_returned?
+            end
 
-                # see also process_payments_before_complete below which needs to
-                # be added in the correct sequence.
-              end
+            event :resume do
+              transition to: :resumed, from: :canceled, if: :canceled?
+            end
 
-              before_transition from: :cart, do: :ensure_line_items_present
+            event :authorize_return do
+              transition to: :awaiting_return
+            end
 
-              if states[:address]
-                before_transition to: :address, do: :assign_default_addresses!
-                before_transition from: :address, do: :persist_user_address!
-              end
+            event :complete do
+              transition to: :complete, from: :confirm
+            end
 
-              if states[:delivery]
-                before_transition to: :delivery, do: :ensure_shipping_address
-                before_transition to: :delivery, do: :create_proposed_shipments
-                before_transition to: :delivery, do: :ensure_available_shipping_rates
-                before_transition to: :delivery, do: :set_shipments_cost
-                before_transition from: :delivery, do: :apply_free_shipping_promotions
+            if states[:payment]
+              event :payment_failed do
+                transition to: :payment, from: :confirm
               end
 
-              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :resumed, do: :validate_line_item_availability
+              after_transition to: :complete, do: :add_payment_sources_to_wallet
+              before_transition to: :payment, do: :add_default_payment_from_wallet
 
-              # Sequence of before_transition to: :complete
-              # calls matter so that we do not process payments
-              # until validations have passed
-              before_transition to: :complete, do: :validate_line_item_availability, unless: :unreturned_exchange?
-              if states[:delivery]
-                before_transition to: :complete, do: :ensure_available_shipping_rates
-              end
-              before_transition to: :complete, do: :ensure_promotions_eligible
-              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :complete, do: :ensure_inventory_units, unless: :unreturned_exchange?
-              if states[:payment]
-                before_transition to: :complete, do: :process_payments_before_complete
-              end
+              before_transition to: :confirm, do: :add_store_credit_payments
 
-              after_transition to: :complete, do: :finalize!
-              after_transition to: :resumed,  do: :after_resume
-              after_transition to: :canceled, do: :after_cancel
+              # see also process_payments_before_complete below which needs to
+              # be added in the correct sequence.
+            end
 
-              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
-                order.update_totals
-                order.persist_totals
-              end
+            before_transition from: :cart, do: :ensure_line_items_present
 
-              after_transition do |order, transition|
-                order.logger.debug "Order #{order.number} transitioned from #{transition.from} to #{transition.to} via #{transition.event}"
-              end
+            if states[:address]
+              before_transition to: :address, do: :assign_default_addresses!
+              before_transition from: :address, do: :persist_user_address!
+            end
 
-              after_failure do |order, transition|
-                order.logger.debug "Order #{order.number} halted transition on event #{transition.event} state #{transition.from}: #{order.errors.full_messages.join}"
-              end
+            if states[:delivery]
+              before_transition to: :delivery, do: :ensure_shipping_address
+              before_transition to: :delivery, do: :create_proposed_shipments
+              before_transition to: :delivery, do: :ensure_available_shipping_rates
+              before_transition from: :delivery, do: :apply_free_shipping_promotions
             end
 
-            alias_method :save_state, :save
-          end
+            before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+            before_transition to: :resumed, do: :validate_line_item_availability
 
-          def self.go_to_state(name, options = {})
-            checkout_steps[name] = options
-            previous_states.each do |state|
-              add_transition({ from: state, to: name }.merge(options))
+            # Sequence of before_transition to: :complete
+            # calls matter so that we do not process payments
+            # until validations have passed
+            before_transition to: :complete, do: :validate_line_item_availability
+            if states[:delivery]
+              before_transition to: :complete, do: :ensure_available_shipping_rates
             end
-            if options[:if]
-              previous_states << name
-            else
-              self.previous_states = [name]
+            before_transition to: :complete, do: :ensure_promotions_eligible
+            before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
+            before_transition to: :complete, do: :ensure_inventory_units
+            if states[:payment]
+              before_transition to: :complete, do: :process_payments_before_complete
             end
-          end
 
-          def self.insert_checkout_step(name, options = {})
-            before = options.delete(:before)
-            after = options.delete(:after) unless before
-            after = checkout_steps.keys.last unless before || after
-
-            cloned_steps = checkout_steps.clone
-            cloned_removed_transitions = removed_transitions.clone
-            checkout_flow do
-              cloned_steps.each_pair do |key, value|
-                go_to_state(name, options) if key == before
-                go_to_state(key, value)
-                go_to_state(name, options) if key == after
-              end
-              cloned_removed_transitions.each do |transition|
-                remove_transition(transition)
-              end
-            end
-          end
+            after_transition to: :complete, do: :finalize!
+            after_transition to: :resumed,  do: :after_resume
+            after_transition to: :canceled, do: :after_cancel
 
-          def self.remove_checkout_step(name)
-            cloned_steps = checkout_steps.clone
-            cloned_removed_transitions = removed_transitions.clone
-            checkout_flow do
-              cloned_steps.each_pair do |key, value|
-                go_to_state(key, value) unless key == name
-              end
-              cloned_removed_transitions.each do |transition|
-                remove_transition(transition)
-              end
+            after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+              order.update!
             end
-          end
-
-          def self.remove_transition(options = {})
-            removed_transitions << options
-            next_event_transitions.delete(find_transition(options))
-          end
 
-          def self.find_transition(options = {})
-            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
-            next_event_transitions.detect do |transition|
-              transition[options[:from].to_sym] == options[:to].to_sym
+            after_transition do |order, transition|
+              order.logger.debug "Order #{order.number} transitioned from #{transition.from} to #{transition.to} via #{transition.event}"
             end
-          end
-
-          def self.next_event_transitions
-            @next_event_transitions ||= []
-          end
-
-          def self.checkout_steps
-            @checkout_steps ||= {}
-          end
 
-          def self.checkout_step_names
-            checkout_steps.keys
-          end
-
-          def self.add_transition(options)
-            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
-          end
-
-          def checkout_steps
-            steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
-              next if options.include?(:if) && !options[:if].call(self)
-              checkout_steps << step
-            }.map(&:to_s)
-            # Ensure there is always a complete step
-            steps << "complete" unless steps.include?("complete")
-            steps
-          end
-
-          def has_checkout_step?(step)
-            step.present? && checkout_steps.include?(step)
-          end
-
-          def passed_checkout_step?(step)
-            has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+            after_failure do |order, transition|
+              order.logger.debug "Order #{order.number} halted transition on event #{transition.event} state #{transition.from}: #{order.errors.full_messages.join}"
+            end
           end
+        end
 
-          def checkout_step_index(step)
-            checkout_steps.index(step).to_i
+        def go_to_state(name, options = {})
+          checkout_steps[name] = options
+          previous_states.each do |state|
+            add_transition({ from: state, to: name }.merge(options))
           end
-
-          def self.removed_transitions
-            @removed_transitions ||= []
+          if options[:if]
+            previous_states << name
+          else
+            self.previous_states = [name]
           end
+        end
 
-          def can_go_to_state?(state)
-            return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
-            checkout_step_index(state) > checkout_step_index(self.state)
+        def insert_checkout_step(name, options = {})
+          before = options.delete(:before)
+          after = options.delete(:after) unless before
+          after = checkout_steps.keys.last unless before || after
+
+          cloned_steps = checkout_steps.clone
+          cloned_removed_transitions = removed_transitions.clone
+          checkout_flow do
+            cloned_steps.each_pair do |key, value|
+              go_to_state(name, options) if key == before
+              go_to_state(key, value)
+              go_to_state(name, options) if key == after
+            end
+            cloned_removed_transitions.each do |transition|
+              remove_transition(transition)
+            end
           end
+        end
 
-          def bill_address_attributes=(attributes)
-            self.bill_address = Address.immutable_merge(bill_address, attributes)
+        def remove_checkout_step(name)
+          cloned_steps = checkout_steps.clone
+          cloned_removed_transitions = removed_transitions.clone
+          checkout_flow do
+            cloned_steps.each_pair do |key, value|
+              go_to_state(key, value) unless key == name
+            end
+            cloned_removed_transitions.each do |transition|
+              remove_transition(transition)
+            end
           end
+        end
 
-          def ship_address_attributes=(attributes)
-            self.ship_address = Address.immutable_merge(ship_address, attributes)
-          end
+        def remove_transition(options = {})
+          removed_transitions << options
+          next_event_transitions.delete(find_transition(options))
+        end
 
-          def assign_default_addresses!
-            if user
-              # this is one of 2 places still using User#bill_address
-              self.bill_address ||= user.bill_address if user.bill_address.try!(:valid?)
-              # Skip setting ship address if order doesn't have a delivery checkout step
-              # to avoid triggering validations on shipping address
-              self.ship_address ||= user.ship_address if user.ship_address.try!(:valid?) && checkout_steps.include?("delivery")
-            end
+        def find_transition(options = {})
+          return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+          next_event_transitions.detect do |transition|
+            transition[options[:from].to_sym] == options[:to].to_sym
           end
+        end
 
-          def persist_user_address!
-            if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
-              user.persist_order_address(self)
-            end
-          end
+        def next_event_transitions
+          @next_event_transitions ||= []
+        end
 
-          def add_payment_sources_to_wallet
-            Spree::Config.
-              add_payment_sources_to_wallet_class.new(self).
-              add_to_wallet
-          end
-          alias_method :persist_user_credit_card, :add_payment_sources_to_wallet
-          deprecate :persist_user_credit_card
+        def checkout_steps
+          @checkout_steps ||= {}
+        end
 
-          def assign_default_credit_card
-            builder = Spree::Config.default_payment_builder_class.new(self)
+        def checkout_step_names
+          checkout_steps.keys
+        end
 
-            if payment = builder.build
-              payments << payment
+        def add_transition(options)
+          next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+        end
 
-              if bill_address.nil?
-                # this is one of 2 places still using User#bill_address
-                self.bill_address = payment.source.try(:address) ||
-                                    user.bill_address
-              end
-            end
-          end
+        def removed_transitions
+          @removed_transitions ||= []
+        end
+      end
 
-          private
+      def checkout_steps
+        steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
+          next if options.include?(:if) && !options[:if].call(self)
+          checkout_steps << step
+        }.map(&:to_s)
+        # Ensure there is always a complete step
+        steps << "complete" unless steps.include?("complete")
+        steps
+      end
 
-          def process_payments_before_complete
-            return if !payment_required?
+      def has_checkout_step?(step)
+        step.present? && checkout_steps.include?(step)
+      end
 
-            if payments.valid.empty?
-              errors.add(:base, Spree.t(:no_payment_found))
-              return false
-            end
+      def passed_checkout_step?(step)
+        has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+      end
 
-            if process_payments!
-              true
-            else
-              saved_errors = errors[:base]
-              payment_failed!
-              saved_errors.each { |error| errors.add(:base, error) }
-              false
-            end
-          end
+      def checkout_step_index(step)
+        checkout_steps.index(step).to_i
+      end
 
-          # In case a existing credit card is provided it needs to build the payment
-          # attributes from scratch so we can set the amount. example payload:
-          #
-          #   {
-          #     "order": {
-          #       "existing_card": "2"
-          #     }
-          #   }
-          #
-          def update_params_payment_source
-            if @updating_params[:order] && (@updating_params[:order][:payments_attributes] || @updating_params[:order][:existing_card])
-              @updating_params[:order][:payments_attributes] ||= [{}]
-              @updating_params[:order][:payments_attributes].first[:amount] = total
-            end
-          end
-        end
+      def can_go_to_state?(state)
+        return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+        checkout_step_index(state) > checkout_step_index(self.state)
       end
     end
   end