spree_core 4.0.0 → 4.6.0

data/app/models/spree/order.rb

@@ -1,7 +1,9 @@
 require_dependency 'spree/order/checkout'
 require_dependency 'spree/order/currency_updater'
+require_dependency 'spree/order/digital'
 require_dependency 'spree/order/payments'
 require_dependency 'spree/order/store_credit'
+require_dependency 'spree/order/emails'
 
 module Spree
   class Order < Spree::Base
@@ -10,18 +12,36 @@ module Spree
 
     include Spree::Order::Checkout
     include Spree::Order::CurrencyUpdater
+    include Spree::Order::Digital
     include Spree::Order::Payments
     include Spree::Order::StoreCredit
     include Spree::Order::AddressBook
+    include Spree::Order::Emails
     include Spree::Core::NumberGenerator.new(prefix: 'R')
     include Spree::Core::TokenGenerator
 
+    include NumberIdentifier
     include NumberAsParam
+    include SingleStoreResource
+    include MemoizedData
+    include Spree::Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::Orders)
+      include Spree::Security::Orders
+    end
+    if defined?(Spree::VendorConcern)
+      include Spree::VendorConcern
+    end
+
+    MEMOIZED_METHODS = %w(tax_zone)
 
     extend Spree::DisplayMoney
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
                   :included_tax_total,  :additional_tax_total, :tax_total,
-                  :shipment_total,      :promo_total,          :total
+                  :shipment_total,      :promo_total,          :total,
+                  :cart_promo_total,    :pre_tax_item_amount,  :pre_tax_total
 
     alias display_ship_total display_shipment_total
     alias_attribute :ship_total, :shipment_total
@@ -47,26 +67,34 @@ module Spree
 
     checkout_flow do
       go_to_state :address
-      go_to_state :delivery
+      go_to_state :delivery, if: ->(order) { order.delivery_required? }
       go_to_state :payment, if: ->(order) { order.payment? || order.payment_required? }
       go_to_state :confirm, if: ->(order) { order.confirmation_required? }
       go_to_state :complete
-      remove_transition from: :delivery, to: :confirm
+      remove_transition from: :delivery, to: :confirm, unless: ->(order) { order.confirmation_required? }
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user promotions bill_address ship_address line_items store]
-    self.whitelisted_ransackable_attributes = %w[completed_at email number state payment_state shipment_state total considered_risky channel]
+    self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store]
+    self.whitelisted_ransackable_attributes = %w[
+      completed_at email number state payment_state shipment_state
+      total item_total considered_risky channel
+    ]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address, :temporary_credit_card
 
+    attribute :state_machine_resumed, :boolean
+
     if Spree.user_class
-      belongs_to :user, class_name: Spree.user_class.to_s, optional: true
-      belongs_to :created_by, class_name: Spree.user_class.to_s, optional: true
-      belongs_to :approver, class_name: Spree.user_class.to_s, optional: true
-      belongs_to :canceler, class_name: Spree.user_class.to_s, optional: true
+      belongs_to :user, class_name: "::#{Spree.user_class}", optional: true
     else
       belongs_to :user, optional: true
+    end
+    if Spree.admin_user_class
+      belongs_to :created_by, class_name: Spree.admin_user_class.to_s, optional: true
+      belongs_to :approver, class_name: Spree.admin_user_class.to_s, optional: true
+      belongs_to :canceler, class_name: Spree.admin_user_class.to_s, optional: true
+    else
       belongs_to :created_by, optional: true
       belongs_to :approver, optional: true
       belongs_to :canceler, optional: true
@@ -92,6 +120,7 @@ module Spree
     has_many :reimbursements, inverse_of: :order, class_name: 'Spree::Reimbursement'
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :inventory_units, inverse_of: :order, class_name: 'Spree::InventoryUnit'
+    has_many :return_items, through: :inventory_units, class_name: 'Spree::ReturnItem'
     has_many :variants, through: :line_items
     has_many :products, through: :variants
     has_many :refunds, through: :payments
@@ -120,15 +149,17 @@ module Spree
     # Needs to happen before save_permalink is called
     before_validation :ensure_store_presence
     before_validation :ensure_currency_presence
+
     before_validation :clone_billing_address, if: :use_billing?
     attr_accessor :use_billing
 
     before_create :create_token
     before_create :link_by_email
-    before_update :homogenize_line_item_currencies, if: :currency_changed?
+    before_update :ensure_updated_shipments, :homogenize_line_item_currencies, if: :currency_changed?
 
     with_options presence: true do
-      validates :number, length: { maximum: 32, allow_blank: true }, uniqueness: { allow_blank: true, case_sensitive: false }
+      # we want to have this case_sentive: true as changing it to false causes all SQL to use LOWER(slug)
+      # which is very costly and slow on large set of records
       validates :email, length: { maximum: 254, allow_blank: true }, email: { allow_blank: true }, if: :require_email
       validates :item_count, numericality: { greater_than_or_equal_to: 0, less_than: 2**31, only_integer: true, allow_blank: true }
       validates :store
@@ -156,6 +187,9 @@ module Spree
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
     scope :complete, -> { where.not(completed_at: nil) }
     scope :incomplete, -> { where(completed_at: nil) }
+    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :with_deleted_bill_address, -> { joins(:bill_address).where.not(Address.table_name => { deleted_at: nil }) }
+    scope :with_deleted_ship_address, -> { joins(:ship_address).where.not(Address.table_name => { deleted_at: nil }) }
 
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order(Arel.sql('spree_orders.completed_at IS NULL'), completed_at: :desc, created_at: :desc) }
@@ -166,14 +200,19 @@ module Spree
       update_hooks.add(hook)
     end
 
-    # For compatiblity with Calculator::PriceSack
+    # For compatibility with Calculator::PriceSack
     def amount
       line_items.inject(0.0) { |sum, li| sum + li.amount }
     end
 
     # Sum of all line item amounts pre-tax
     def pre_tax_item_amount
-      line_items.to_a.sum(&:pre_tax_amount)
+      line_items.sum(:pre_tax_amount)
+    end
+
+    # Sum of all line item and shipment pre-tax
+    def pre_tax_total
+      pre_tax_item_amount + shipments.sum(:pre_tax_amount)
     end
 
     def shipping_discount
@@ -192,6 +231,11 @@ module Spree
       line_items.exists?
     end
 
+    # Does this order require a physical delivery.
+    def delivery_required?
+      !digital?
+    end
+
     # Is this a free order in which case the payment step should be skipped
     def payment_required?
       total.to_f > 0.0
@@ -296,15 +340,15 @@ module Spree
     def outstanding_balance
       if canceled?
         -1 * payment_total
-      elsif refunds.exists?
-        # If refund has happened add it back to total to prevent balance_due payment state
-        # See: https://github.com/spree/spree/issues/6229 & https://github.com/spree/spree/issues/8136
-        total - (payment_total + refunds.sum(:amount))
       else
-        total - payment_total
+        total - (payment_total + reimbursement_paid_total)
       end
     end
 
+    def reimbursement_paid_total
+      reimbursements.sum(&:paid_amount)
+    end
+
     def outstanding_balance?
       outstanding_balance != 0
     end
@@ -319,6 +363,10 @@ module Spree
       complete? || resumed? || awaiting_return? || returned?
     end
 
+    def uneditable?
+      complete? || canceled? || returned?
+    end
+
     def credit_cards
       credit_card_ids = payments.from_credit_card.pluck(:source_id).uniq
       CreditCard.where(id: credit_card_ids)
@@ -349,6 +397,7 @@ module Spree
       touch :completed_at
 
       deliver_order_confirmation_email unless confirmation_delivered?
+      deliver_store_owner_order_notification_email if deliver_store_owner_order_notification_email?
 
       consider_risk
     end
@@ -359,18 +408,17 @@ module Spree
       save!
     end
 
-    def deliver_order_confirmation_email
-      OrderMailer.confirm_email(id).deliver_later
-      update_column(:confirmation_delivered, true)
-    end
-
     # Helper methods for checkout steps
     def paid?
-      payment_state == 'paid' || payment_state == 'credit_owed'
+      payments.valid.completed.size == payments.valid.size && payments.valid.sum(:amount) >= total
     end
 
-    def available_payment_methods
-      @available_payment_methods ||= collect_payment_methods
+    def available_payment_methods(store = nil)
+      if store.present?
+        ActiveSupport::Deprecation.warn('The `store` parameter is deprecated and will be removed in Spree 5. Order is already associated with Store')
+      end
+
+      @available_payment_methods ||= collect_payment_methods(store)
     end
 
     def insufficient_stock_lines
@@ -401,21 +449,15 @@ module Spree
     end
 
     def empty!
-      if completed?
-        raise Spree.t(:cannot_empty_completed_order)
-      else
-        line_items.destroy_all
-        updater.update_item_count
-        adjustments.destroy_all
-        shipments.destroy_all
-        state_changes.destroy_all
-        order_promotions.destroy_all
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `Order#empty!` is deprecated and will be removed in Spree 5.0.
+        Please use `Spree::Cart::Empty.call(order: order)` instead.
+      DEPRECATION
 
-        update_totals
-        persist_totals
-        restart_checkout_flow
-        self
-      end
+      raise Spree.t(:cannot_empty_completed_order) if completed?
+
+      result = Spree::Dependencies.cart_empty_service.constantize.call(order: self)
+      result.value
     end
 
     def has_step?(step)
@@ -458,6 +500,10 @@ module Spree
       %w(partial shipped).include?(shipment_state)
     end
 
+    def fully_shipped?
+      shipments.shipped.size == shipments.size
+    end
+
     def create_proposed_shipments
       all_adjustments.shipping.delete_all
 
@@ -553,6 +599,10 @@ module Spree
       !approved?
     end
 
+    def can_be_destroyed?
+      !completed? && payments.completed.empty?
+    end
+
     def consider_risk
       considered_risky! if is_risky? && !approved?
     end
@@ -565,11 +615,6 @@ module Spree
       update_column(:considered_risky, false)
     end
 
-    def reload(options = nil)
-      remove_instance_variable(:@tax_zone) if defined?(@tax_zone)
-      super
-    end
-
     def tax_total
       included_tax_total + additional_tax_total
     end
@@ -601,19 +646,16 @@ module Spree
       promotions.pluck(:code).compact.first
     end
 
-    def payments_attributes=(attributes)
-      validate_payments_attributes(attributes)
-      super(attributes)
-    end
-
     def validate_payments_attributes(attributes)
+      ActiveSupport::Deprecation.warn('`Order#validate_payments_attributes` is deprecated and will be removed in Spree 5')
+
       # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods.map(&:id))
+      payment_method_ids = available_payment_methods.map(&:id).map(&:to_s)
+
       attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
+        payment_method_id = payment_attributes[:payment_method_id].to_s
 
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
+        raise ActiveRecord::RecordNotFound unless payment_method_ids.include?(payment_method_id)
       end
     end
 
@@ -625,6 +667,28 @@ module Spree
       all_adjustments.eligible.nonzero.promotion.map { |a| a.source.promotion_id }.uniq
     end
 
+    def valid_coupon_promotions
+      promotions.
+        where(id: valid_promotion_ids).
+        coupons
+    end
+
+    # Returns item and whole order discount amount for Order
+    # without Shipment disccounts (eg. Free Shipping)
+    # @return [BigDecimal]
+    def cart_promo_total
+      all_adjustments.eligible.nonzero.promotion.
+        where.not(adjustable_type: 'Spree::Shipment').
+        sum(:amount)
+    end
+
+    def has_free_shipping?
+      shipment_adjustments.
+        joins(:promotion_action).
+        where(spree_adjustments: { eligible: true, source_type: 'Spree::PromotionAction' },
+              spree_promotion_actions: { type: 'Spree::Promotion::Actions::FreeShipping' }).exists?
+    end
+
     private
 
     def link_by_email
@@ -662,10 +726,6 @@ module Spree
       update_with_updater!
     end
 
-    def send_cancel_email
-      OrderMailer.cancel_email(id).deliver_later
-    end
-
     def after_resume
       shipments.each(&:resume!)
       consider_risk
@@ -676,15 +736,20 @@ module Spree
     end
 
     def ensure_currency_presence
-      self.currency ||= store.default_currency || Spree::Config[:currency]
+      self.currency ||= store.default_currency
     end
 
     def create_token
       self.token ||= generate_token
     end
 
-    def collect_payment_methods
-      PaymentMethod.available_on_front_end.select { |pm| pm.available_for_order?(self) }
+    def collect_payment_methods(store = nil)
+      if store.present?
+        ActiveSupport::Deprecation.warn('The `store` parameter is deprecated and will be removed in Spree 5. Order is already associated with Store')
+      end
+      store ||= self.store
+
+      store.payment_methods.available_on_front_end.select { |pm| pm.available_for_order?(self) }
     end
 
     def credit_card_nil_payment?(attributes)

data/app/models/spree/order_inventory.rb

@@ -120,7 +120,7 @@ module Spree
       if order.completed?
         current_on_hand = shipment.stock_location.count_on_hand(variant)
 
-        if current_on_hand.negative? && current_on_hand.abs < removed_backordered
+        if current_on_hand&.negative? && current_on_hand.abs < removed_backordered
           shipment.stock_location.restock_backordered variant, current_on_hand.abs, shipment
         else
           shipment.stock_location.restock_backordered variant, removed_backordered, shipment

data/app/models/spree/order_merger.rb

@@ -54,7 +54,7 @@ module Spree
 
     # Change the error messages as you choose.
     def handle_error(line_item)
-      order.errors[:base] << line_item.errors.full_messages
+      order.errors.add(:base, line_item.errors.full_messages)
     end
 
     def persist_merge

data/app/models/spree/order_promotion.rb

@@ -3,7 +3,7 @@ module Spree
     belongs_to :order, class_name: 'Spree::Order'
     belongs_to :promotion, class_name: 'Spree::Promotion'
 
-    delegate :name, :description, :code, to: :promotion
+    delegate :name, :description, :code, :public_metadata, to: :promotion
     delegate :currency, to: :order
 
     extend Spree::DisplayMoney

data/app/models/spree/payment/processing.rb

@@ -72,7 +72,7 @@ module Spree
       end
 
       def cancel!
-        response = payment_method.cancel(response_code)
+        response = payment_method.cancel(response_code, self)
         handle_response(response, :void, :failure)
       end
 
@@ -152,6 +152,7 @@ module Spree
       def protect_from_connection_error
         yield
       rescue ActiveMerchant::ConnectionError => e
+        failure!
         gateway_error(e)
       end
 
@@ -163,8 +164,8 @@ module Spree
                else
                  error.to_s
                end
-        logger.error(Spree.t(:gateway_error))
-        logger.error("  #{error.to_yaml}")
+        Rails.logger.error(Spree.t(:gateway_error))
+        Rails.logger.error("  #{error.to_yaml}")
         raise Core::GatewayError, text
       end
 

data/app/models/spree/payment.rb

@@ -3,18 +3,25 @@ require_dependency 'spree/payment/processing'
 module Spree
   class Payment < Spree::Base
     include Spree::Core::NumberGenerator.new(prefix: 'P', letters: true, length: 7)
+    include NumberIdentifier
+    include NumberAsParam
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::Payments)
+      include Spree::Security::Payments
+    end
 
     include Spree::Payment::Processing
 
-    include NumberAsParam
-
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
-    INVALID_STATES      = %w(failed invalid).freeze
+    INVALID_STATES      = %w(failed invalid void).freeze
 
     with_options inverse_of: :payments do
       belongs_to :order, class_name: 'Spree::Order', touch: true
-      belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+      belongs_to :payment_method, -> { with_deleted }, class_name: 'Spree::PaymentMethod'
     end
     belongs_to :source, polymorphic: true
 
@@ -25,8 +32,8 @@ module Spree
     has_many :refunds, inverse_of: :payment
 
     validates :payment_method, presence: true
-    validates :number, uniqueness: { case_sensitive: true }
     validates :source, presence: true, if: -> { payment_method&.source_required? }
+    validate :payment_method_available_for_order, on: :create
 
     before_validation :validate_source
 
@@ -66,6 +73,9 @@ module Spree
     scope :store_credits, -> { where(source_type: Spree::StoreCredit.to_s) }
     scope :not_store_credits, -> { where(arel_table[:source_type].not_eq(Spree::StoreCredit.to_s).or(arel_table[:source_type].eq(nil))) }
 
+    self.whitelisted_ransackable_associations = %w[payment_method order source]
+    self.whitelisted_ransackable_attributes = %w[number amount state response_code avs_response cvv_response_code cvv_response_message]
+
     # transaction_id is much easier to understand
     def transaction_id
       response_code
@@ -95,10 +105,12 @@ module Spree
       event :complete do
         transition from: [:processing, :pending, :checkout], to: :completed
       end
+      after_transition to: :completed, do: :after_completed
       event :void do
         transition from: [:pending, :processing, :completed, :checkout], to: :void
       end
-      # when the card brand isnt supported
+      after_transition to: :void, do: :after_void
+      # when the card brand isn't supported
       event :invalidate do
         transition from: [:checkout], to: :invalid
       end
@@ -112,6 +124,13 @@ module Spree
       end
     end
 
+    def source
+      return super if payment_method.nil?
+      return super unless payment_method.source_required?
+
+      payment_method.payment_source_class.unscoped { super }
+    end
+
     def money
       Spree::Money.new(amount, currency: currency)
     end
@@ -189,20 +208,49 @@ module Spree
 
     private
 
+    def after_void
+      # this method is prepended in api/ to queue Webhooks requests
+    end
+
+    def after_completed
+      # this method is prepended in api/ to queue Webhooks requests
+    end
+
     def has_invalid_state?
       INVALID_STATES.include?(state)
     end
 
     def validate_source
       if source && !source.valid?
-        source.errors.each do |field, error|
-          field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-          errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{error}")
+        if Rails::VERSION::STRING >= '6.1'
+          source.errors.map { |error| { field: error.attribute, message: error&.message } }.each do |err|
+            next if err[:field].blank? || err[:message].blank?
+
+            add_source_error(err[:field], err[:message])
+          end
+        else
+          source.errors.messages.each do |field, error|
+            next if field.blank? || error.empty?
+
+            add_source_error(field, error.first)
+          end
         end
       end
       !errors.present?
     end
 
+    def payment_method_available_for_order
+      return if payment_method.blank?
+      return if order.blank?
+
+      errors.add(:payment_method, :invalid) if !payment_method.available_for_order?(order) || !payment_method.available_for_store?(order.store)
+    end
+
+    def add_source_error(field, message)
+      field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
+      errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{message}")
+    end
+
     def profiles_supported?
       payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
     end

data/app/models/spree/payment_capture_event.rb

@@ -1,5 +1,9 @@
 module Spree
   class PaymentCaptureEvent < Spree::Base
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     belongs_to :payment, class_name: 'Spree::Payment'
 
     def display_amount

data/app/models/spree/payment_method/store_credit.rb

@@ -74,7 +74,7 @@ module Spree
       handle_action(action, :credit, auth_code)
     end
 
-    def cancel(auth_code)
+    def cancel(auth_code, _payment = nil)
       store_credit_event = StoreCreditEvent.find_by(authorization_code: auth_code,
                                                     action: Spree::StoreCredit::CAPTURE_ACTION)
       store_credit = store_credit_event.try(:store_credit)

data/app/models/spree/payment_method.rb

@@ -3,6 +3,12 @@ module Spree
     acts_as_paranoid
     acts_as_list
 
+    include MultiStoreResource
+    include Spree::Metadata
+    if defined?(Spree::Security::PaymentMethods)
+      include Spree::Security::PaymentMethods
+    end
+
     DISPLAY = [:both, :front_end, :back_end].freeze
 
     scope :active,                 -> { where(active: true).order(position: :asc) }
@@ -12,6 +18,9 @@ module Spree
 
     validates :name, presence: true
 
+    has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod'
+    has_many :stores, class_name: 'Spree::Store', through: :store_payment_methods
+
     with_options dependent: :restrict_with_error do
       has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method
       has_many :credit_cards, class_name: 'Spree::CreditCard'
@@ -29,6 +38,8 @@ module Spree
     # e.g. CreditCard in the case of a the Gateway payment type
     # nil means the payment method doesn't require a source e.g. check
     def payment_source_class
+      return unless source_required?
+
       raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
     end
 
@@ -75,5 +86,23 @@ module Spree
     def available_for_order?(_order)
       true
     end
+
+    def available_for_store?(store)
+      return true if store.blank?
+
+      store_ids.include?(store.id)
+    end
+
+    def public_preferences
+      public_preference_keys.each_with_object({}) do |key, hash|
+        hash[key] = preferences[key]
+      end
+    end
+
+    protected
+
+    def public_preference_keys
+      []
+    end
   end
 end

data/app/models/spree/payment_source.rb

@@ -0,0 +1,10 @@
+module Spree
+  class PaymentSource < Spree::Base
+    include Metadata
+
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    belongs_to :user, class_name: 'Spree::User', optional: true
+
+    validates_uniqueness_of :gateway_payment_profile_id, scope: :type
+  end
+end

data/app/models/spree/preference.rb

@@ -1,5 +1,10 @@
 class Spree::Preference < Spree::Base
   serialize :value
 
-  validates :key, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+  validates :key, presence: true,
+                  uniqueness: { case_sensitive: false, allow_blank: true, scope: spree_base_uniqueness_scope }
+
+  if defined?(Spree::Security::Preferences)
+    include Spree::Security::Preferences
+  end
 end