solidus_core 2.1.1 → 2.2.0.beta1

data/app/models/spree/order.rb

@@ -2,11 +2,11 @@ require 'spree/core/validators/email'
 require 'spree/order/checkout'
 
 module Spree
-  # The customers cart until completed, then acts as permenent record of the transaction.
+  # The customers cart until completed, then acts as permanent record of the transaction.
   #
   # `Spree::Order` is the heart of the Solidus system, as it acts as the customer's
   # cart as they shop. Once an order is complete, it serves as the
-  # permenent record of their purchase. It has many responsibilities:
+  # permanent record of their purchase. It has many responsibilities:
   #
   # * Records and validates attributes like `total` and relationships like
   # `Spree::LineItem` as an ActiveRecord model.
@@ -43,17 +43,20 @@ module Spree
       go_to_state :confirm
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user promotions bill_address ship_address line_items]
+    self.whitelisted_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
     self.whitelisted_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
 
     attr_reader :coupon_code
-    attr_accessor :temporary_address, :temporary_credit_card
+    attr_accessor :temporary_address
 
-    belongs_to :user, class_name: Spree::UserClassHandle.new
-    belongs_to :created_by, class_name: Spree::UserClassHandle.new
-    belongs_to :approver, class_name: Spree::UserClassHandle.new
-    belongs_to :canceler, class_name: Spree::UserClassHandle.new
+    attr_accessor :temporary_payment_source
+    alias_method :temporary_credit_card, :temporary_payment_source
+    alias_method :temporary_credit_card=, :temporary_payment_source=
+    deprecate temporary_credit_card: :temporary_payment_source, deprecator: Spree::Deprecation
+    deprecate :temporary_credit_card= => :temporary_payment_source=, deprecator: Spree::Deprecation
 
+    # Customer info
+    belongs_to :user, class_name: Spree::UserClassHandle.new
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
     alias_attribute :billing_address, :bill_address
 
@@ -62,36 +65,48 @@ module Spree
     alias_attribute :ship_total, :shipment_total
 
     belongs_to :store, class_name: 'Spree::Store'
-    has_many :state_changes, as: :stateful
+
+    # Items
     has_many :line_items, -> { order(:created_at, :id) }, dependent: :destroy, inverse_of: :order
-    has_many :payments, dependent: :destroy, inverse_of: :order
-    has_many :return_authorizations, dependent: :destroy, inverse_of: :order
-    has_many :reimbursements, inverse_of: :order
+    has_many :variants, through: :line_items
+    has_many :products, through: :variants
+
+    # Shipping
+    has_many :inventory_units, inverse_of: :order
+    has_many :cartons, -> { distinct }, through: :inventory_units
+    has_many :shipments, dependent: :destroy, inverse_of: :order do
+      def states
+        pluck(:state).uniq
+      end
+    end
+    has_many :order_stock_locations, class_name: "Spree::OrderStockLocation"
+    has_many :stock_locations, through: :order_stock_locations
+
+    # Adjustments and promotions
     has_many :adjustments, -> { order(:created_at) }, as: :adjustable, inverse_of: :adjustable, dependent: :destroy
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :shipment_adjustments, through: :shipments, source: :adjustments
-    has_many :inventory_units, inverse_of: :order
-    has_many :products, through: :variants
-    has_many :variants, through: :line_items
-    has_many :refunds, through: :payments
     has_many :all_adjustments,
              class_name: 'Spree::Adjustment',
              foreign_key: :order_id,
              dependent: :destroy,
              inverse_of: :order
-
-    has_many :order_stock_locations, class_name: "Spree::OrderStockLocation"
-    has_many :stock_locations, through: :order_stock_locations
-
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :promotions, through: :order_promotions
 
-    has_many :cartons, -> { distinct }, through: :inventory_units
-    has_many :shipments, dependent: :destroy, inverse_of: :order do
-      def states
-        pluck(:state).uniq
-      end
-    end
+    # Payments
+    has_many :payments, dependent: :destroy, inverse_of: :order
+
+    # Returns
+    has_many :return_authorizations, dependent: :destroy, inverse_of: :order
+    has_many :reimbursements, inverse_of: :order
+    has_many :refunds, through: :payments
+
+    # Logging
+    has_many :state_changes, as: :stateful
+    belongs_to :created_by, class_name: Spree::UserClassHandle.new
+    belongs_to :approver, class_name: Spree::UserClassHandle.new
+    belongs_to :canceler, class_name: Spree::UserClassHandle.new
 
     accepts_nested_attributes_for :line_items
     accepts_nested_attributes_for :bill_address
@@ -111,6 +126,7 @@ module Spree
 
     validates :email, presence: true, if: :require_email
     validates :email, email: true, allow_blank: true
+    validates :guest_token, presence: { allow_nil: true }
     validates :number, presence: true, uniqueness: { allow_blank: true }
     validates :store_id, presence: true
 
@@ -134,7 +150,6 @@ module Spree
 
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order('spree_orders.completed_at IS NULL', completed_at: :desc, created_at: :desc) }
-    scope :unreturned_exchange, -> { joins(:shipments).where('spree_orders.created_at > spree_shipments.created_at') }
 
     def self.by_customer(customer)
       joins(:user).where("#{Spree.user_class.table_name}.email" => customer)
@@ -220,7 +235,7 @@ module Spree
     # Returns the relevant zone (if any) to be used for taxation purposes.
     # Uses default tax zone unless there is a specific match
     def tax_zone
-      Zone.match(tax_address) || Zone.default_tax
+      Spree::Zone.match(tax_address) || Spree::Zone.default_tax
     end
     deprecate tax_zone: "Please use Spree::Order#tax_address instead.",
               deprecator: Spree::Deprecation
@@ -235,7 +250,7 @@ module Spree
     end
 
     def updater
-      @updater ||= OrderUpdater.new(self)
+      @updater ||= Spree::OrderUpdater.new(self)
     end
 
     def update!
@@ -381,12 +396,12 @@ module Spree
 
     def credit_cards
       credit_card_ids = payments.from_credit_card.pluck(:source_id).uniq
-      CreditCard.where(id: credit_card_ids)
+      Spree::CreditCard.where(id: credit_card_ids)
     end
 
     def valid_credit_cards
       credit_card_ids = payments.from_credit_card.valid.pluck(:source_id).uniq
-      CreditCard.where(id: credit_card_ids)
+      Spree::CreditCard.where(id: credit_card_ids)
     end
 
     # Finalizes an in progress order after checkout is complete.
@@ -418,7 +433,7 @@ module Spree
     end
 
     def deliver_order_confirmation_email
-      OrderMailer.confirm_email(self).deliver_later
+      Spree::OrderMailer.confirm_email(self).deliver_later
       update_column(:confirmation_delivered, true)
     end
 
@@ -429,10 +444,10 @@ module Spree
 
     def available_payment_methods
       @available_payment_methods ||= Spree::PaymentMethod
+        .active
         .available_to_store(store)
         .available_to_users
-        .active
-        .sort_by(&:position)
+        .order(:position)
     end
 
     def insufficient_stock_lines
@@ -458,17 +473,14 @@ module Spree
 
     def empty!
       line_items.destroy_all
-      updater.update_item_count
       adjustments.destroy_all
       shipments.destroy_all
 
-      update_totals
-      persist_totals
+      update!
     end
 
-    def has_step?(step)
-      checkout_steps.include?(step)
-    end
+    alias_method :has_step?, :has_checkout_step?
+    deprecate has_step?: :has_checkout_step?, deprecator: Spree::Deprecation
 
     def state_changed(name)
       state = "#{name}_state"
@@ -509,8 +521,6 @@ module Spree
     end
 
     def create_proposed_shipments
-      return shipments if unreturned_exchange?
-
       if completed?
         raise CannotRebuildShipments.new(Spree.t(:cannot_rebuild_shipments_order_completed))
       elsif shipments.any? { |s| !s.pending? }
@@ -559,9 +569,9 @@ module Spree
 
     def set_shipments_cost
       shipments.each(&:update_amounts)
-      updater.update_shipment_total
-      persist_totals
+      update!
     end
+    deprecate set_shipments_cost: :update!, deprecator: Spree::Deprecation
 
     def is_risky?
       payments.risky.count > 0
@@ -599,18 +609,6 @@ module Spree
       guest_token
     end
 
-    def unreturned_exchange?
-      # created_at - 1 is a hack to ensure that this doesn't blow up on MySQL,
-      # records loaded from the DB on MySQL will have a precision of 1 second,
-      # but records in memory may still have miliseconds on them, causing this
-      # to be true where it shouldn't be.
-      #
-      # FIXME: find a better way to determine if an order is an unreturned
-      # exchange
-      shipment = shipments.first
-      shipment.present? ? (shipment.created_at < created_at - 1) : false
-    end
-
     def tax_total
       additional_tax_total + included_tax_total
     end
@@ -690,25 +688,90 @@ module Spree
       Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: currency })
     end
 
-    def payments_attributes=(attributes)
-      validate_payments_attributes(attributes)
-      super(attributes)
+    def bill_address_attributes=(attributes)
+      self.bill_address = Spree::Address.immutable_merge(bill_address, attributes)
+    end
+
+    def ship_address_attributes=(attributes)
+      self.ship_address = Spree::Address.immutable_merge(ship_address, attributes)
     end
 
-    def validate_payments_attributes(attributes)
-      attributes = Array.wrap(attributes)
-      # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods)
-      attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
+    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
+    end
 
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
+    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 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: :add_payment_sources_to_wallet, deprecator: Spree::Deprecation
+
+    def add_default_payment_from_wallet
+      builder = Spree::Config.default_payment_builder_class.new(self)
+
+      if payment = builder.build
+        payments << payment
+
+        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
+    alias_method :assign_default_credit_card, :add_default_payment_from_wallet
+    deprecate assign_default_credit_card: :add_default_payment_from_wallet, deprecator: Spree::Deprecation
+
     private
 
+    def process_payments_before_complete
+      return if !payment_required?
+
+      if payments.valid.empty?
+        errors.add(:base, Spree.t(:no_payment_found))
+        return false
+      end
+
+      if process_payments!
+        true
+      else
+        saved_errors = errors[:base]
+        payment_failed!
+        saved_errors.each { |error| errors.add(:base, error) }
+        false
+      end
+    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
+
     def associate_store
       self.store ||= Spree::Store.default
     end
@@ -723,7 +786,7 @@ module Spree
     end
 
     def ensure_inventory_units
-      if has_step?("delivery")
+      if has_checkout_step?("delivery")
         inventory_validator = Spree::Stock::InventoryValidator.new
 
         errors = line_items.map { |line_item| inventory_validator.validate(line_item) }.compact
@@ -732,9 +795,12 @@ module Spree
     end
 
     def ensure_promotions_eligible
-      updater.update_adjustment_total
-      if promo_total_changed?
+      adjustment_changed = all_adjustments.eligible.promotion.any? do |adjustment|
+        !adjustment.calculate_eligibility
+      end
+      if adjustment_changed
         restart_checkout_flow
+        update!
         errors.add(:base, Spree.t(:promotion_total_changed_before_complete))
       end
       errors.empty?
@@ -770,7 +836,7 @@ module Spree
     end
 
     def send_cancel_email
-      OrderMailer.cancel_email(self).deliver_later
+      Spree::OrderMailer.cancel_email(self).deliver_later
     end
 
     def after_resume

data/app/models/spree/order_contents.rb

@@ -80,7 +80,7 @@ module Spree
     end
 
     def order_updater
-      @updater ||= OrderUpdater.new(order)
+      @updater ||= Spree::OrderUpdater.new(order)
     end
 
     def reload_totals

data/app/models/spree/order_inventory.rb

@@ -18,13 +18,13 @@ module Spree
     def verify(shipment = nil)
       if order.completed? || shipment.present?
 
-        if inventory_units.size < line_item.quantity
-          quantity = line_item.quantity - inventory_units.size
-
-          shipment = determine_target_shipment unless shipment
-          add_to_shipment(shipment, quantity)
-        elsif inventory_units.size > line_item.quantity
-          remove(inventory_units, shipment)
+        existing_quantity = inventory_units.count
+        desired_quantity = line_item.quantity - existing_quantity
+        if desired_quantity > 0
+          shipment ||= determine_target_shipment
+          add_to_shipment(shipment, desired_quantity)
+        elsif desired_quantity < 0
+          remove(-desired_quantity, shipment)
         end
       end
     end
@@ -35,9 +35,7 @@ module Spree
 
     private
 
-    def remove(item_units, shipment = nil)
-      quantity = item_units.size - line_item.quantity
-
+    def remove(quantity, shipment = nil)
       if shipment.present?
         remove_from_shipment(shipment, quantity)
       else
@@ -100,7 +98,9 @@ module Spree
         removed_quantity += 1
       end
 
-      shipment.destroy if shipment.inventory_units.count == 0
+      if shipment.inventory_units.count.zero?
+        order.shipments.destroy(shipment)
+      end
 
       # removing this from shipment, and adding to stock_location
       if order.completed?

data/app/models/spree/order_promotion.rb

@@ -14,6 +14,8 @@ module Spree
     validates :promotion, presence: true
     validates :promotion_code, presence: true, if: :require_promotion_code?
 
+    self.whitelisted_ransackable_associations = %w[promotion_code]
+
     private
 
     def require_promotion_code?

data/app/models/spree/order_update_attributes.rb

@@ -14,17 +14,10 @@ module Spree
     # Assign the attributes to the order and save the order
     # @return true if saved, otherwise false and errors will be set on the order
     def apply
-      order.validate_payments_attributes(@payments_attributes)
-
       assign_order_attributes
       assign_payments_attributes
 
-      if order.save
-        order.set_shipments_cost if order.shipments.any?
-        true
-      else
-        false
-      end
+      order.save
     end
 
     private

data/app/models/spree/order_updater.rb

@@ -17,6 +17,7 @@ module Spree
     def update
       @order.transaction do
         update_item_count
+        update_shipment_amounts
         update_totals
         if order.completed?
           update_payment_state
@@ -32,6 +33,65 @@ module Spree
       update_hooks.each { |hook| order.send hook }
     end
 
+    # Updates the +shipment_state+ attribute according to the following logic:
+    #
+    # shipped   when all Shipments are in the "shipped" state
+    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+    # ready     when all Shipments are in the "ready" state
+    # backorder when there is backordered inventory associated with an order
+    # pending   when all Shipments are in the "pending" state
+    #
+    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_shipment_state
+      if order.backordered?
+        order.shipment_state = 'backorder'
+      else
+        # get all the shipment states for this order
+        shipment_states = shipments.states
+        if shipment_states.size > 1
+          # multiple shiment states means it's most likely partially shipped
+          order.shipment_state = 'partial'
+        else
+          # will return nil if no shipments are found
+          order.shipment_state = shipment_states.first
+          # TODO: inventory unit states?
+          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
+          #   shipments exist but there are unassigned inventory units
+          #   order.shipment_state = 'partial'
+          # end
+        end
+      end
+
+      order.state_changed('shipment')
+      order.shipment_state
+    end
+
+    # Updates the +payment_state+ attribute according to the following logic:
+    #
+    # paid          when +payment_total+ is equal to +total+
+    # balance_due   when +payment_total+ is less than +total+
+    # credit_owed   when +payment_total+ is greater than +total+
+    # failed        when most recent payment is in the failed state
+    #
+    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_payment_state
+      last_state = order.payment_state
+      if payments.present? && payments.valid.size == 0 && order.outstanding_balance != 0
+        order.payment_state = 'failed'
+      elsif order.state == 'canceled' && order.payment_total == 0
+        order.payment_state = 'void'
+      else
+        order.payment_state = 'balance_due' if order.outstanding_balance > 0
+        order.payment_state = 'credit_owed' if order.outstanding_balance < 0
+        order.payment_state = 'paid' if !order.outstanding_balance?
+      end
+      order.state_changed('payment') if last_state != order.payment_state
+      order.payment_state
+    end
+
+    private
+
     # This will update and select the best promotion adjustment, update tax
     # adjustments, update cancellation adjustments, and then update the total
     # fields (promo_total, included_tax_total, additional_tax_total, and
@@ -64,13 +124,16 @@ module Spree
       update_adjustment_total
     end
 
+    def update_shipment_amounts
+      shipments.each do |shipment|
+        shipment.update_amounts
+      end
+    end
+
     # give each of the shipments a chance to update themselves
     def update_shipments
       shipments.each do |shipment|
-        next unless shipment.persisted?
         shipment.update!(order)
-        shipment.refresh_rates
-        shipment.update_amounts
       end
     end
 
@@ -102,7 +165,7 @@ module Spree
     end
 
     def update_item_count
-      order.item_count = quantity
+      order.item_count = line_items.to_a.sum(&:quantity)
     end
 
     def update_item_total
@@ -114,65 +177,6 @@ module Spree
       order.save!(validate: false)
     end
 
-    # Updates the +shipment_state+ attribute according to the following logic:
-    #
-    # shipped   when all Shipments are in the "shipped" state
-    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
-    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
-    # ready     when all Shipments are in the "ready" state
-    # backorder when there is backordered inventory associated with an order
-    # pending   when all Shipments are in the "pending" state
-    #
-    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
-    def update_shipment_state
-      if order.backordered?
-        order.shipment_state = 'backorder'
-      else
-        # get all the shipment states for this order
-        shipment_states = shipments.states
-        if shipment_states.size > 1
-          # multiple shiment states means it's most likely partially shipped
-          order.shipment_state = 'partial'
-        else
-          # will return nil if no shipments are found
-          order.shipment_state = shipment_states.first
-          # TODO: inventory unit states?
-          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
-          #   shipments exist but there are unassigned inventory units
-          #   order.shipment_state = 'partial'
-          # end
-        end
-      end
-
-      order.state_changed('shipment')
-      order.shipment_state
-    end
-
-    # Updates the +payment_state+ attribute according to the following logic:
-    #
-    # paid          when +payment_total+ is equal to +total+
-    # balance_due   when +payment_total+ is less than +total+
-    # credit_owed   when +payment_total+ is greater than +total+
-    # failed        when most recent payment is in the failed state
-    #
-    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
-    def update_payment_state
-      last_state = order.payment_state
-      if payments.present? && payments.valid.size == 0 && order.outstanding_balance != 0
-        order.payment_state = 'failed'
-      elsif order.state == 'canceled' && order.payment_total == 0
-        order.payment_state = 'void'
-      else
-        order.payment_state = 'balance_due' if order.outstanding_balance > 0
-        order.payment_state = 'credit_owed' if order.outstanding_balance < 0
-        order.payment_state = 'paid' if !order.outstanding_balance?
-      end
-      order.state_changed('payment') if last_state != order.payment_state
-      order.payment_state
-    end
-
-    private
-
     def round_money(n)
       (n * 100).round / 100.0
     end

data/app/models/spree/payment.rb

@@ -40,7 +40,6 @@ module Spree
 
     validates :amount, numericality: true
     validates :source, presence: true, if: :source_required?
-    validates :payment_method, presence: true
 
     default_scope -> { order(:created_at) }