spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/option_type.rb

@@ -13,7 +13,7 @@ module Spree
     after_touch :touch_all_products
 
     def touch_all_products
-      products.find_each(&:touch)
+      products.update_all(updated_at: Time.current)
     end
   end
 end

data/app/models/spree/option_value.rb

@@ -8,15 +8,8 @@ module Spree
 
     after_touch :touch_all_variants
 
-    self.whitelisted_ransackable_attributes = ['presentation']
-
     def touch_all_variants
-      # This can cause a cascade of products to be updated
-      # To disable it in Rails 4.1, we can do this:
-      # https://github.com/rails/rails/pull/12772
-      # Spree::Product.no_touching do
-        variants.find_each(&:touch)
-      # end
+      variants.update_all(updated_at: Time.current)
     end
   end
 end

data/app/models/spree/order.rb

@@ -3,8 +3,14 @@ require 'spree/order/checkout'
 
 module Spree
   class Order < Spree::Base
+
+    ORDER_NUMBER_LENGTH  = 9
+    ORDER_NUMBER_LETTERS = false
+    ORDER_NUMBER_PREFIX  = 'R'
+
     include Spree::Order::Checkout
     include Spree::Order::CurrencyUpdater
+    include Spree::Order::Payments
 
     checkout_flow do
       go_to_state :address
@@ -15,20 +21,19 @@ module Spree
       remove_transition from: :delivery, to: :confirm
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user promotions bill_address ship_address line_items]
-    self.whitelisted_ransackable_attributes =  %w[completed_at created_at email number state payment_state shipment_state total considered_risky]
-
     attr_reader :coupon_code
-    attr_accessor :temporary_address
+    attr_accessor :temporary_address, :temporary_credit_card
 
     if Spree.user_class
       belongs_to :user, class_name: Spree.user_class.to_s
       belongs_to :created_by, class_name: Spree.user_class.to_s
       belongs_to :approver, class_name: Spree.user_class.to_s
+      belongs_to :canceler, class_name: Spree.user_class.to_s
     else
       belongs_to :user
       belongs_to :created_by
       belongs_to :approver
+      belongs_to :canceler
     end
 
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
@@ -40,20 +45,17 @@ module Spree
     alias_attribute :ship_total, :shipment_total
 
     has_many :state_changes, as: :stateful
-    has_many :line_items, -> { order("#{LineItem.table_name}.created_at ASC") }, dependent: :destroy, inverse_of: :order
+    has_many :line_items, -> { order('created_at ASC') }, dependent: :destroy, inverse_of: :order
     has_many :payments, dependent: :destroy
-    has_many :return_authorizations, dependent: :destroy, inverse_of: :order
+    has_many :return_authorizations, dependent: :destroy
+    has_many :reimbursements, inverse_of: :order
     has_many :adjustments, -> { order("#{Adjustment.table_name}.created_at ASC") }, as: :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 :all_adjustments,
-             class_name: 'Spree::Adjustment',
-             foreign_key: :order_id,
-             dependent: :destroy,
-             inverse_of: :order
+    has_many :refunds, through: :payments
 
     has_and_belongs_to_many :promotions, join_table: 'spree_orders_promotions'
 
@@ -82,7 +84,7 @@ module Spree
 
     validates :email, presence: true, if: :require_email
     validates :email, email: true, if: :require_email, allow_blank: true
-    validates :number, presence: true, uniqueness: { allow_blank: true }
+    validates :number, uniqueness: true
     validate :has_available_shipment
 
     make_permalink field: :number
@@ -92,6 +94,9 @@ module Spree
     class_attribute :update_hooks
     self.update_hooks = Set.new
 
+    class_attribute :line_item_comparison_hooks
+    self.line_item_comparison_hooks = Set.new
+
     def self.by_number(number)
       where(number: number)
     end
@@ -99,7 +104,8 @@ module Spree
     scope :created_between, ->(start_date, end_date) { where(created_at: start_date..end_date) }
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
 
-    scope :reverse_chronological, -> { order(created_at: :desc) }
+    # 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) }
 
     def self.by_customer(customer)
       joins(:user).where("#{Spree.user_class.table_name}.email" => customer)
@@ -129,11 +135,21 @@ module Spree
       self.line_item_comparison_hooks.add(hook)
     end
 
+    def all_adjustments
+      Adjustment.where("order_id = :order_id OR (adjustable_id = :order_id AND adjustable_type = 'Spree::Order')",
+                       order_id: self.id)
+    end
+
     # For compatiblity 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)
+    end
+
     def currency
       self[:currency] || Spree::Config[:currency]
     end
@@ -243,8 +259,8 @@ module Spree
       shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
     end
 
-    def awaiting_returns?
-      return_authorizations.any? { |return_authorization| return_authorization.authorized? }
+    def all_inventory_units_returned?
+      inventory_units.all? { |inventory_unit| inventory_unit.returned? }
     end
 
     def contents
@@ -265,35 +281,62 @@ module Spree
       end
     end
 
-    def generate_order_number(digits = 9)
+    def generate_order_number(options = {})
+      options[:length]  ||= ORDER_NUMBER_LENGTH
+      options[:letters] ||= ORDER_NUMBER_LETTERS
+      options[:prefix]  ||= ORDER_NUMBER_PREFIX
+
+      possible = (0..9).to_a
+      possible += ('A'..'Z').to_a if options[:letters]
+
       self.number ||= loop do
-         # Make a random number.
-         random = "R#{Array.new(digits){rand(10)}.join}"
-         # Use the random  number if no other order exists with it.
-         if self.class.exists?(number: random)
-           # If over half of all possible options are taken add another digit.
-           digits += 1 if self.class.count > (10 ** digits / 2)
-         else
-           break random
-         end
-       end
+        # Make a random number.
+        random = "#{options[:prefix]}#{(0...options[:length]).map { possible.shuffle.first }.join}"
+        # Use the random  number if no other order exists with it.
+        if self.class.exists?(number: random)
+          # If over half of all possible options are taken add another digit.
+          options[:length] += 1 if self.class.count > (10 ** options[:length] / 2)
+        else
+          break random
+        end
+      end
     end
 
     def shipped_shipments
       shipments.shipped
     end
 
-    def contains?(variant)
-      find_line_item_by_variant(variant).present?
+    def contains?(variant, options = {})
+      find_line_item_by_variant(variant, options).present?
     end
 
-    def quantity_of(variant)
-      line_item = find_line_item_by_variant(variant)
+    def quantity_of(variant, options = {})
+      line_item = find_line_item_by_variant(variant, options)
       line_item ? line_item.quantity : 0
     end
 
-    def find_line_item_by_variant(variant)
-      line_items.detect { |line_item| line_item.variant_id == variant.id }
+    def find_line_item_by_variant(variant, options = {})
+      line_items.detect { |line_item|
+                    line_item.variant_id == variant.id &&
+                    line_item_options_match(line_item, options)
+                  }
+    end
+
+    # This method enables extensions to participate in the
+    # "Are these line items equal" decision.
+    #
+    # When adding to cart, an extension would send something like:
+    # params[:product_customizations]={...}
+    #
+    # and would provide:
+    #
+    # def product_customizations_match
+    def line_item_options_match(line_item, options)
+      return true unless options
+
+      self.line_item_comparison_hooks.all? { |hook|
+        self.send(hook, line_item, options)
+      }
     end
 
     # Creates new tax charges if there are any applicable rates. If prices already
@@ -306,7 +349,7 @@ module Spree
     end
 
     def outstanding_balance
-      if state == 'canceled'
+      if self.state == 'canceled' && self.payments.present? && self.payments.completed.size > 0
         -1 * payment_total
       else
         total - payment_total
@@ -314,7 +357,7 @@ module Spree
     end
 
     def outstanding_balance?
-     self.outstanding_balance != 0
+      self.outstanding_balance != 0
     end
 
     def name
@@ -332,6 +375,11 @@ module 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)
+    end
+
     # Finalizes an in progress order after checkout is complete.
     # Called after transition to complete state when payments will have been processed
     def finalize!
@@ -346,7 +394,7 @@ module Spree
       end
 
       updater.update_shipment_state
-      save
+      save!
       updater.run_hooks
 
       touch :completed_at
@@ -356,12 +404,6 @@ module Spree
       consider_risk
     end
 
-    def fulfill!
-      shipments.each { |shipment| shipment.update!(self) if shipment.persisted? }
-      updater.update_shipment_state
-      save!
-    end
-
     def deliver_order_confirmation_email
       OrderMailer.confirm_email(self.id).deliver
       update_column(:confirmation_delivered, true)
@@ -376,46 +418,6 @@ module Spree
       @available_payment_methods ||= (PaymentMethod.available(:front_end) + PaymentMethod.available(:both)).uniq
     end
 
-    def pending_payments
-      payments.select { |payment| payment.checkout? || payment.pending? }
-    end
-
-    # processes any pending payments and must return a boolean as it's
-    # return value is used by the checkout state_machine to determine
-    # success or failure of the 'complete' event for the order
-    #
-    # Returns:
-    #
-    # - true if all pending_payments processed successfully
-    #
-    # - true if a payment failed, ie. raised a GatewayError
-    #   which gets rescued and converted to TRUE when
-    #   :allow_checkout_gateway_error is set to true
-    #
-    # - false if a payment failed, ie. raised a GatewayError
-    #   which gets rescued and converted to FALSE when
-    #   :allow_checkout_on_gateway_error is set to false
-    #
-    def process_payments!\
-      # Don't run if there is nothing to pay.
-      return if payment_total >= total
-      # Prevent orders from transitioning to complete without a successfully processed payment.
-      raise Core::GatewayError.new(Spree.t(:no_payment_found)) if pending_payments.empty?
-
-      pending_payments.each do |payment|
-        break if payment_total >= total
-
-        payment.process!
-
-        if payment.completed?
-          self.payment_total += payment.amount
-        end
-      end
-    rescue Core::GatewayError => e
-      result = !!Spree::Config[:allow_checkout_on_gateway_error]
-      errors.add(:base, e.message) and return result
-    end
-
     def billing_firstname
       bill_address.try(:firstname)
     end
@@ -425,29 +427,34 @@ module Spree
     end
 
     def insufficient_stock_lines
-     line_items.select(&:insufficient_stock?)
+      line_items.select(&:insufficient_stock?)
     end
 
     def ensure_line_items_are_in_stock
       if insufficient_stock_lines.present?
-        errors.add(:base, Spree.t(:insufficient_stock_lines_present))
-        restart_checkout_flow
-        false
-      else
-        true
+        errors.add(:base, Spree.t(:insufficient_stock_lines_present)) and return false
       end
     end
 
     def merge!(order, user = nil)
-      order.line_items.each do |line_item|
-        next unless line_item.currency == currency
-        current_line_item = self.line_items.find_by(variant: line_item.variant)
+      order.line_items.each do |other_order_line_item|
+        next unless other_order_line_item.currency == currency
+
+        # Compare the line items of the other order with mine.
+        # Make sure you allow any extensions to chime in on whether or
+        # not the extension-specific parts of the line item match
+        current_line_item = self.line_items.detect { |my_li|
+                      my_li.variant == other_order_line_item.variant &&
+                      self.line_item_comparison_hooks.all? { |hook|
+                        self.send(hook, my_li, other_order_line_item)
+                      }
+                    }
         if current_line_item
-          current_line_item.quantity += line_item.quantity
-          current_line_item.save
+          current_line_item.quantity += other_order_line_item.quantity
+          current_line_item.save!
         else
-          line_item.order_id = self.id
-          line_item.save
+          other_order_line_item.order_id = self.id
+          other_order_line_item.save!
         end
       end
 
@@ -506,15 +513,9 @@ module Spree
     end
 
     def create_proposed_shipments
-      all_adjustments.shipping.delete_all
+      adjustments.shipping.delete_all
       shipments.destroy_all
-
-      packages = Spree::Stock::Coordinator.new(self).packages
-      packages.each do |package|
-        shipments << package.to_shipment
-      end
-
-      shipments
+      self.shipments = Spree::Stock::Coordinator.new(self).shipments
     end
 
     def apply_free_shipping_promotions
@@ -539,9 +540,10 @@ module Spree
 
     def restart_checkout_flow
       self.update_columns(
-        state: checkout_steps.first,
+        state: 'cart',
         updated_at: Time.now,
       )
+      self.next! if self.line_items.size > 0
     end
 
     def refresh_shipment_rates
@@ -557,11 +559,22 @@ module Spree
       updater.update_shipment_total
       persist_totals
     end
+    Spree.instrument_method self, :set_shipments_cost
 
     def is_risky?
       self.payments.risky.count > 0
     end
 
+    def canceled_by(user)
+      self.transaction do
+        cancel!
+        self.update_columns(
+          canceler_id: user.id,
+          canceled_at: Time.now,
+        )
+      end
+    end
+
     def approved_by(user)
       self.transaction do
         approve!
@@ -620,38 +633,43 @@ module Spree
       line_items.sum(:quantity)
     end
 
+    def has_non_reimbursement_related_refunds?
+      refunds.non_reimbursement.exists? ||
+        payments.offset_payment.exists? # how old versions of spree stored refunds
+    end
+
     private
 
-      def link_by_email
-        self.email = user.email if self.user
-      end
+    def link_by_email
+      self.email = user.email if self.user
+    end
 
-      # Determine if email is required (we don't want validation errors before we hit the checkout)
-      def require_email
-        true unless new_record? or ['cart', 'address'].include?(state)
-      end
+    # Determine if email is required (we don't want validation errors before we hit the checkout)
+    def require_email
+      true unless new_record? or ['cart', 'address'].include?(state)
+    end
 
-      def ensure_line_items_present
-        unless line_items.present?
-          errors.add(:base, Spree.t(:there_are_no_items_for_this_order)) and return false
-        end
+    def ensure_line_items_present
+      unless line_items.present?
+        errors.add(:base, Spree.t(:there_are_no_items_for_this_order)) and return false
       end
+    end
 
-      def has_available_shipment
-        return unless has_step?("delivery")
-        return unless address?
-        return unless ship_address && ship_address.valid?
-        # errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
-      end
+    def has_available_shipment
+      return unless has_step?("delivery")
+      return unless has_step?(:address) && address?
+      return unless ship_address && ship_address.valid?
+      # errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
+    end
 
-      def ensure_available_shipping_rates
-        if shipments.empty? || shipments.any? { |shipment| shipment.shipping_rates.blank? }
-          # After this point, order redirects back to 'address' state and asks user to pick a proper address
-          # Therefore, shipments are not necessary at this point.
-          shipments.delete_all
-          errors.add(:base, Spree.t(:items_cannot_be_shipped)) and return false
-        end
+    def ensure_available_shipping_rates
+      if shipments.empty? || shipments.any? { |shipment| shipment.shipping_rates.blank? }
+        # After this point, order redirects back to 'address' state and asks user to pick a proper address
+        # Therefore, shipments are not necessary at this point.
+        shipments.delete_all
+        errors.add(:base, Spree.t(:items_cannot_be_shipped)) and return false
       end
+    end
 
     def after_cancel
       shipments.each { |shipment| shipment.cancel! }
@@ -660,28 +678,28 @@ module Spree
       self.update!
     end
 
-      def send_cancel_email
-        OrderMailer.cancel_email(self.id).deliver
-      end
+    def send_cancel_email
+      OrderMailer.cancel_email(self.id).deliver
+    end
 
-      def after_resume
-        shipments.each { |shipment| shipment.resume! }
-        consider_risk
-      end
+    def after_resume
+      shipments.each { |shipment| shipment.resume! }
+      consider_risk
+    end
 
-      def use_billing?
-        @use_billing == true || @use_billing == 'true' || @use_billing == '1'
-      end
+    def use_billing?
+      @use_billing == true || @use_billing == 'true' || @use_billing == '1'
+    end
 
-      def set_currency
-        self.currency = Spree::Config[:currency] if self[:currency].nil?
-      end
+    def set_currency
+      self.currency = Spree::Config[:currency] if self[:currency].nil?
+    end
 
-      def create_token
-        self.guest_token ||= loop do
-          random_token = SecureRandom.urlsafe_base64(nil, false)
-          break random_token unless self.class.exists?(guest_token: random_token)
-        end
+    def create_token
+      self.guest_token ||= loop do
+        random_token = SecureRandom.urlsafe_base64(nil, false)
+        break random_token unless self.class.exists?(guest_token: random_token)
       end
+    end
   end
 end