solidus_core 4.6.2 → 4.7.0

data/app/models/spree/credit_card.rb

@@ -4,7 +4,7 @@ module Spree
   # The default `source` of a `Spree::Payment`.
   #
   class CreditCard < Spree::PaymentSource
-    belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: 'user_id', optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: "user_id", optional: true
     belongs_to :address, optional: true
 
     before_save :set_last_digits
@@ -14,28 +14,28 @@ module Spree
     attr_reader :number, :verification_value
     attr_accessor :encrypted_data
 
-    validates :month, :year, numericality: { only_integer: true }, if: :require_card_numbers?, on: :create
+    validates :month, :year, numericality: {only_integer: true}, if: :require_card_numbers?, on: :create
     validates :number, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
     validates :name, presence: true, if: :require_card_numbers?, on: :create
     validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
 
-    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :with_payment_profile, -> { where("gateway_customer_profile_id IS NOT NULL") }
 
     # Taken from ActiveMerchant
     # https://github.com/activemerchant/active_merchant/blob/2f2acd4696e8de76057b5ed670b9aa022abc1187/lib/active_merchant/billing/credit_card_methods.rb#L5
     CARD_TYPES = {
-      'visa'               => /^4\d{12}(\d{3})?(\d{3})?$/,
-      'master'             => /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\d{10}$/,
-      'discover'           => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
-      'american_express'   => /^3[47]\d{13}$/,
-      'diners_club'        => /^3(0[0-5]|[68]\d)\d{11}$/,
-      'jcb'                => /^35(28|29|[3-8]\d)\d{12}$/,
-      'switch'             => /^6759\d{12}(\d{2,3})?$/,
-      'solo'               => /^6767\d{12}(\d{2,3})?$/,
-      'dankort'            => /^5019\d{12}$/,
-      'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
-      'forbrugsforeningen' => /^600722\d{10}$/,
-      'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
+      "visa" => /^4\d{12}(\d{3})?(\d{3})?$/,
+      "master" => /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\d{10}$/,
+      "discover" => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
+      "american_express" => /^3[47]\d{13}$/,
+      "diners_club" => /^3(0[0-5]|[68]\d)\d{11}$/,
+      "jcb" => /^35(28|29|[3-8]\d)\d{12}$/,
+      "switch" => /^6759\d{12}(\d{2,3})?$/,
+      "solo" => /^6767\d{12}(\d{2,3})?$/,
+      "dankort" => /^5019\d{12}$/,
+      "maestro" => /^(5[06-8]|6\d)\d{10,17}$/,
+      "forbrugsforeningen" => /^600722\d{10}$/,
+      "laser" => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
     }.freeze
 
     def address_attributes=(attributes)
@@ -50,9 +50,9 @@ module Spree
       return unless expiry.present?
 
       self[:month], self[:year] =
-        if expiry =~ /\d{2}\s?\/\s?\d{2,4}/ # will match mm/yy and mm / yyyy
-          expiry.delete(' ').split('/')
-        elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
+        if /\d{2}\s?\/\s?\d{2,4}/.match?(expiry) # will match mm/yy and mm / yyyy
+          expiry.delete(" ").split("/")
+        elsif (match = expiry.match(/(\d{2})(\d{2,4})/)) # will match mmyy and mmyyyy
           [match[1], match[2]]
         end
       if self[:year]
@@ -68,12 +68,12 @@ module Spree
     def number=(num)
       @number =
         if num.is_a?(String)
-          num.gsub(/[^0-9]/, '')
+          num.gsub(/[^0-9]/, "")
         end
     end
 
     def verification_value=(value)
-      @verification_value = value.to_s.gsub(/\s/, '')
+      @verification_value = value.to_s.gsub(/\s/, "")
     end
 
     # Sets the credit card type, converting it to the preferred internal
@@ -84,10 +84,10 @@ module Spree
       # cc_type is set by jquery.payment, which helpfully provides different
       # types from Active Merchant. Converting them is necessary.
       self[:cc_type] = case type
-                       when 'mastercard', 'maestro' then 'master'
-                       when 'amex' then 'american_express'
-                       when 'dinersclub' then 'diners_club'
-                       when '' then try_type_from_number
+      when "mastercard", "maestro" then "master"
+      when "amex" then "american_express"
+      when "dinersclub" then "diners_club"
+      when "" then try_type_from_number
       else type
       end
     end
@@ -100,16 +100,16 @@ module Spree
 
     # Sets the last digits field based on the assigned credit card number.
     def set_last_digits
-      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..)
+      self.last_digits ||= (number.to_s.length <= 4) ? number : number.to_s.slice(-4..)
     end
 
     # @return [String] the credit card type if it can be determined from the
     #   number, otherwise the empty string
     def try_type_from_number
       CARD_TYPES.each do |type, pattern|
-        return type if number =~ pattern
+        return type if number&.match?(pattern)
       end
-      ''
+      ""
     end
 
     # @return [Boolean] true when a verification value is present

data/app/models/spree/customer_return.rb

@@ -18,9 +18,10 @@ module Spree
 
     accepts_nested_attributes_for :return_items
 
-    self.allowed_ransackable_attributes = ['number']
+    self.allowed_ransackable_attributes = ["number"]
 
     extend DisplayMoney
+
     money_methods :total, :total_excluding_vat, :amount
 
     delegate :currency, to: :order
@@ -61,14 +62,14 @@ module Spree
 
     def generate_number
       self.number ||= loop do
-        random = "CR#{Array.new(9){ rand(9) }.join}"
+        random = "CR#{Array.new(9) { rand(9) }.join}"
         break random unless self.class.exists?(number: random)
       end
     end
 
     def return_items_belong_to_same_order
-      if return_items.reject{ |return_item| return_item.inventory_unit&.order_id == order_id }.any?
-        errors.add(:base, I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
+      if return_items.reject { |return_item| return_item.inventory_unit&.order_id == order_id }.any?
+        errors.add(:base, I18n.t("spree.return_items_cannot_be_associated_with_multiple_orders"))
       end
     end
 

data/app/models/spree/distributed_amounts_handler.rb

@@ -21,7 +21,7 @@ module Spree
     # @return [Hash<Integer, BigDecimal>] a hash of line item IDs and their
     #   corresponding weighted adjustments
     def distributed_amounts
-      Hash[line_item_ids.zip(allocated_amounts)]
+      line_item_ids.zip(allocated_amounts).to_h
     end
 
     def line_item_ids

data/app/models/spree/fulfilment_changer.rb

@@ -32,7 +32,7 @@ module Spree
       @track_inventory = track_inventory
     end
 
-    validates :quantity, numericality: { greater_than: 0 }
+    validates :quantity, numericality: {greater_than: 0}
     validate :current_shipment_not_already_shipped
     validate :desired_shipment_different_from_current
     validates :desired_stock_location, presence: true
@@ -113,19 +113,19 @@ module Spree
         # We order by state, because `'backordered' < 'on_hand'`.
         # We start to move the new actual backordered quantity, so the remaining
         # quantity can be set to on_hand state.
-        current_shipment.
-          inventory_units.
-          where(variant:).
-          order(state: :asc).
-          limit(backordered_quantity_to_move).
-          update_all(shipment_id: desired_shipment.id, state: :backordered)
-
-        current_shipment.
-          inventory_units.
-          where(variant:).
-          order(state: :asc).
-          limit(on_hand_quantity_to_move).
-          update_all(shipment_id: desired_shipment.id, state: :on_hand)
+        current_shipment
+          .inventory_units
+          .where(variant:)
+          .order(state: :asc)
+          .limit(backordered_quantity_to_move)
+          .update_all(shipment_id: desired_shipment.id, state: :backordered)
+
+        current_shipment
+          .inventory_units
+          .where(variant:)
+          .order(state: :asc)
+          .limit(on_hand_quantity_to_move)
+          .update_all(shipment_id: desired_shipment.id, state: :on_hand)
       end
     end
 
@@ -133,12 +133,12 @@ module Spree
     # to the other.
     def run_without_tracking_inventory
       ActiveRecord::Base.transaction do
-        current_shipment.
-          inventory_units.
-          where(variant:).
-          order(state: :asc).
-          limit(quantity).
-          update_all(shipment_id: desired_shipment.id)
+        current_shipment
+          .inventory_units
+          .where(variant:)
+          .order(state: :asc)
+          .limit(quantity)
+          .update_all(shipment_id: desired_shipment.id)
       end
     end
 
@@ -181,11 +181,11 @@ module Spree
     end
 
     def desired_location_quantifier
-      @desired_location_quantifier ||= Spree::Stock::Quantifier.new(variant, desired_stock_location)
+      @desired_location_quantifier ||= Spree::Config.stock.quantifier_class.new(variant, desired_stock_location)
     end
 
     def current_location_quantifier
-      @current_location_quantifier ||= Spree::Stock::Quantifier.new(variant, current_stock_location)
+      @current_location_quantifier ||= Spree::Config.stock.quantifier_class.new(variant, current_stock_location)
     end
 
     def desired_shipment_different_from_current

data/app/models/spree/image/active_storage_attachment.rb

@@ -12,8 +12,8 @@ module Spree::Image::ActiveStorageAttachment
     validate :supported_content_type
 
     has_attachment :attachment,
-                   styles: Spree::Config.product_image_styles,
-                   default_style: Spree::Config.product_image_style_default
+      styles: Spree::Config.product_image_styles,
+      default_style: Spree::Config.product_image_style_default
 
     def supported_content_type
       unless attachment.content_type.in?(Spree::Config.allowed_image_mime_types)

data/app/models/spree/image/paperclip_attachment.rb

@@ -7,15 +7,15 @@ module Spree::Image::PaperclipAttachment
     validate :no_attachment_errors
 
     has_attached_file :attachment,
-                      styles: Spree::Config.product_image_styles,
-                      default_style: Spree::Config.product_image_style_default,
-                      default_url: 'noimage/:style.png',
-                      url: '/spree/products/:id/:style/:basename.:extension',
-                      path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
-                      convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
+      styles: Spree::Config.product_image_styles,
+      default_style: Spree::Config.product_image_style_default,
+      default_url: "noimage/:style.png",
+      url: "/spree/products/:id/:style/:basename.:extension",
+      path: ":rails_root/public/spree/products/:id/:style/:basename.:extension",
+      convert_options: {all: "-strip -auto-orient -colorspace sRGB"}
     validates_attachment :attachment,
       presence: true,
-      content_type: { content_type: Spree::Config.allowed_image_mime_types }
+      content_type: {content_type: Spree::Config.allowed_image_mime_types}
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet
@@ -39,7 +39,7 @@ module Spree::Image::PaperclipAttachment
     filename = temporary.path unless temporary.nil?
     filename = attachment.path if filename.blank?
     geometry = Paperclip::Geometry.from_file(filename)
-    self.attachment_width  = geometry.width
+    self.attachment_width = geometry.width
     self.attachment_height = geometry.height
   end
 

data/app/models/spree/in_memory_order_updater.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "spree/manipulative_query_monitor"
+
+module Spree
+  class InMemoryOrderUpdater
+    attr_reader :order
+
+    # logs a warning when a manipulative query is made when the persist flag is set to false
+    class_attribute :log_manipulative_queries
+    self.log_manipulative_queries = true
+
+    delegate :payments, :line_items, :adjustments, :all_adjustments, :shipments, :quantity, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # This is a multi-purpose method for processing logic related to changes in the Order.
+    # It is meant to be called from various observers so that the Order is aware of changes
+    # that affect totals and other values stored in the Order.
+    #
+    # This method should never do anything to the Order that results in a save call on the
+    # object with callbacks (otherwise you will end up in an infinite recursion as the
+    # associations try to save and then in turn try to call +update!+ again.)
+    def recalculate(persist: true)
+      monitor =
+        if log_manipulative_queries
+          Spree::ManipulativeQueryMonitor
+        else
+          proc { |&block| block.call }
+        end
+
+      order.transaction do
+        monitor.call do
+          recalculate_line_item_prices
+          recalculate_item_count
+          assign_shipment_amounts
+        end
+
+        if persist
+          update_totals(persist:)
+        else
+          monitor.call do
+            update_totals(persist:)
+          end
+        end
+
+        monitor.call do
+          if order.completed?
+            recalculate_payment_state
+            recalculate_shipment_state
+          end
+        end
+
+        Spree::Bus.publish(:order_recalculated, order:)
+
+        persist_totals if persist
+      end
+    end
+    alias_method :update, :recalculate
+    deprecate update: :recalculate, deprecator: Spree.deprecator
+
+    # Recalculates the state on all of them shipments, then recalculates 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 recalculate_shipment_state
+      shipments.each(&:recalculate_state)
+
+      order.shipment_state = determine_shipment_state
+      order.shipment_state
+    end
+    alias_method :update_shipment_state, :recalculate_shipment_state
+    deprecate update_shipment_state: :recalculate_shipment_state, deprecator: Spree.deprecator
+
+    # Recalculates 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
+    # void          when the order has been canceled and the payment total is 0
+    #
+    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def recalculate_payment_state
+      order.payment_state = determine_payment_state
+      order.payment_state
+    end
+    alias_method :update_payment_state, :recalculate_payment_state
+    deprecate update_payment_state: :recalculate_payment_state, deprecator: Spree.deprecator
+
+    private
+
+    def determine_payment_state
+      if payments.present? && payments.valid.empty? && order.outstanding_balance != 0
+        "failed"
+      elsif order.state == "canceled" && order.payment_total.zero?
+        "void"
+      elsif order.outstanding_balance > 0
+        "balance_due"
+      elsif order.outstanding_balance < 0
+        "credit_owed"
+      else
+        # outstanding_balance == 0
+        "paid"
+      end
+    end
+
+    def determine_shipment_state
+      if order.backordered?
+        "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
+          "partial"
+        else
+          # will return nil if no shipments are found
+          shipment_states.first
+        end
+      end
+    end
+
+    # 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
+    # adjustment_total) on the item.
+    # @return [void]
+    def update_adjustments(persist:)
+      # Promotion adjustments must be applied first, then tax adjustments.
+      # This fits the criteria for VAT tax as outlined here:
+      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
+      # It also fits the criteria for sales tax as outlined here:
+      # http://www.boe.ca.gov/formspubs/pub113/
+      update_promotions(persist:)
+      update_tax_adjustments
+      assign_item_totals
+    end
+
+    # Updates the following Order total values:
+    #
+    # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+    # +item_total+         The total value of all LineItems
+    # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
+    # +promo_total+        The total value of all promotion adjustments
+    # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
+    def update_totals(persist:)
+      recalculate_payment_total
+      recalculate_item_total
+      recalculate_shipment_total
+      update_adjustment_total(persist:)
+    end
+
+    def assign_shipment_amounts
+      shipments.each(&:assign_amounts)
+    end
+
+    def update_adjustment_total(persist:)
+      update_adjustments(persist:)
+
+      all_items = line_items + shipments
+      # Ignore any adjustments that have been marked for destruction in our
+      # calculations. They'll get removed when/if we persist the order.
+      valid_adjustments = adjustments.reject(&:marked_for_destruction?)
+      order_tax_adjustments = valid_adjustments.select(&:tax?)
+
+      order.adjustment_total = all_items.sum(&:adjustment_total) + valid_adjustments.sum(&:amount)
+      order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
+
+      recalculate_order_total
+    end
+
+    def update_promotions(persist:)
+      Spree::Config.promotions.order_adjuster_class.new(order).call(persist:)
+    end
+
+    def update_tax_adjustments
+      Spree::Config.tax_adjuster_class.new(order).adjust!
+    end
+
+    def update_cancellations
+    end
+    deprecate :update_cancellations, deprecator: Spree.deprecator
+
+    def assign_item_totals
+      [*line_items, *shipments].each do |item|
+        Spree::Config.item_total_class.new(item).recalculate!
+
+        next unless item.changed?
+
+        item.assign_attributes(
+          promo_total: item.promo_total,
+          included_tax_total: item.included_tax_total,
+          additional_tax_total: item.additional_tax_total,
+          adjustment_total: item.adjustment_total
+        )
+      end
+    end
+
+    def recalculate_payment_total
+      order.payment_total = payments.completed.includes(:refunds).sum { |payment| payment.amount - payment.refunds.sum(:amount) }
+    end
+
+    def recalculate_shipment_total
+      order.shipment_total = shipments.to_a.sum(&:cost)
+      recalculate_order_total
+    end
+
+    def recalculate_order_total
+      order.total = order.item_total + order.shipment_total + order.adjustment_total
+    end
+
+    def recalculate_item_count
+      order.item_count = line_items.to_a.sum(&:quantity)
+    end
+
+    def recalculate_item_total
+      order.item_total = line_items.to_a.sum(&:amount)
+      recalculate_order_total
+    end
+
+    def recalculate_line_item_prices
+      if Spree::Config.recalculate_cart_prices
+        line_items.each(&:recalculate_price)
+      end
+    end
+
+    def persist_totals
+      shipments.each(&:persist_amounts)
+      assign_item_totals
+      log_state_change("payment")
+      log_state_change("shipment")
+      order.save!
+    end
+
+    def log_state_change(name)
+      state = "#{name}_state"
+      previous_state, current_state = order.changes[state]
+
+      if previous_state != current_state
+        # Enqueue the job to track this state change
+        StateChangeTrackingJob.perform_later(
+          order,
+          previous_state,
+          current_state,
+          Time.current,
+          name
+        )
+      end
+    end
+  end
+end

data/app/models/spree/inventory_unit.rb

@@ -4,9 +4,9 @@ module Spree
   # Tracks the state of line items' fulfillment.
   #
   class InventoryUnit < Spree::Base
-    PRE_SHIPMENT_STATES = %w(backordered on_hand)
-    POST_SHIPMENT_STATES = %w(returned)
-    CANCELABLE_STATES = ['on_hand', 'backordered', 'shipped']
+    PRE_SHIPMENT_STATES = %w[backordered on_hand]
+    POST_SHIPMENT_STATES = %w[returned]
+    CANCELABLE_STATES = ["on_hand", "backordered", "shipped"]
 
     belongs_to :variant, -> { with_discarded }, class_name: "Spree::Variant", inverse_of: :inventory_units, optional: true
     belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units, optional: true
@@ -29,20 +29,20 @@ module Spree
     before_destroy :ensure_can_destroy
 
     scope :pending, -> { where pending: true }
-    scope :backordered, -> { where state: 'backordered' }
-    scope :on_hand, -> { where state: 'on_hand' }
+    scope :backordered, -> { where state: "backordered" }
+    scope :on_hand, -> { where state: "on_hand" }
     scope :pre_shipment, -> { where(state: PRE_SHIPMENT_STATES) }
-    scope :shipped, -> { where state: 'shipped' }
+    scope :shipped, -> { where state: "shipped" }
     scope :post_shipment, -> { where(state: POST_SHIPMENT_STATES) }
-    scope :returned, -> { where state: 'returned' }
-    scope :canceled, -> { where(state: 'canceled') }
-    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :returned, -> { where state: "returned" }
+    scope :canceled, -> { where(state: "canceled") }
+    scope :not_canceled, -> { where.not(state: "canceled") }
     scope :cancelable, -> { where(state: Spree::InventoryUnit::CANCELABLE_STATES, pending: false) }
     scope :backordered_per_variant, ->(stock_item) do
       includes(:shipment, :order)
         .where("spree_shipments.state != 'canceled'").references(:shipment)
         .where(variant_id: stock_item.variant_id)
-        .where('spree_orders.completed_at is not null')
+        .where("spree_orders.completed_at is not null")
         .backordered.order(Spree::Order.arel_table[:completed_at].asc)
     end
 
@@ -53,7 +53,7 @@ module Spree
     #   inventory units for the given stock item
     scope :backordered_for_stock_item, ->(stock_item) do
       backordered_per_variant(stock_item)
-        .where(spree_shipments: { stock_location_id: stock_item.stock_location_id })
+        .where(spree_shipments: {stock_location_id: stock_item.stock_location_id})
     end
 
     scope :shippable, -> { on_hand }

data/app/models/spree/item_total.rb

@@ -14,7 +14,7 @@ class Spree::ItemTotal
     # These ones should not affect the eventual total price.
     #
     # Additional tax adjustments are the opposite, affecting the final total.
-    item.included_tax_total   = tax_adjustments.select(&:included?).sum(&:amount)
+    item.included_tax_total = tax_adjustments.select(&:included?).sum(&:amount)
     item.additional_tax_total = tax_adjustments.reject(&:included?).sum(&:amount)
 
     item.adjustment_total = item.adjustments.reject { |adjustment|

data/app/models/spree/legacy_user.rb

@@ -9,10 +9,10 @@ module Spree
     include UserMethods
     include Metadata
 
-    self.table_name = 'spree_users'
+    self.table_name = "spree_users"
 
     def self.model_name
-      ActiveModel::Name.new Spree::LegacyUser, Spree, 'user'
+      ActiveModel::Name.new Spree::LegacyUser, Spree, "user"
     end
 
     attr_accessor :password