solidus_core 3.0.0.rc2 → 3.1.0

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

@@ -9,17 +9,17 @@ module Spree
 
     def authorize(_money, credit_card, _options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, { message: FAILURE_MESSAGE }, test: true)
       end
     end
 
     def purchase(_money, credit_card, _options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, message: FAILURE_MESSAGE, test: true)
       end
     end
   end

data/app/models/spree/payment_method.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'spree/preferences/persistable'
 require 'spree/preferences/statically_configurable'
 
 module Spree
@@ -11,6 +12,8 @@ module Spree
   # This class is not meant to be instantiated. Please create instances of concrete payment methods.
   #
   class PaymentMethod < Spree::Base
+    include Spree::Preferences::Persistable
+
     preference :server, :string, default: 'test'
     preference :test_mode, :boolean, default: true
 

data/app/models/spree/price.rb

@@ -13,7 +13,7 @@ module Spree
     delegate :tax_rates, to: :variant
 
     validate :check_price
-    validates :amount, allow_nil: true, numericality: {
+    validates :amount, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }

data/app/models/spree/product/scopes.rb

@@ -29,25 +29,25 @@ module Spree
           scope :descend_by_name, -> { order(name: :desc) }
 
           add_search_scope :ascend_by_master_price do
-            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+            joins(master: :prices).select('spree_products.* , spree_prices.amount')
                                          .order(Spree::Price.arel_table[:amount].asc)
           end
 
           add_search_scope :descend_by_master_price do
-            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+            joins(master: :prices).select('spree_products.* , spree_prices.amount')
                                          .order(Spree::Price.arel_table[:amount].desc)
           end
 
           add_search_scope :price_between do |low, high|
-            joins(master: :default_price).where(Price.table_name => { amount: low..high })
+            joins(master: :prices).where(Price.table_name => { amount: low..high })
           end
 
           add_search_scope :master_price_lte do |price|
-            joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
+            joins(master: :prices).where("#{price_table_name}.amount <= ?", price)
           end
 
           add_search_scope :master_price_gte do |price|
-            joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
+            joins(master: :prices).where("#{price_table_name}.amount >= ?", price)
           end
 
           # This scope selects products in taxon AND all its descendants

data/app/models/spree/product.rb

@@ -45,7 +45,6 @@ module Spree
 
     has_many :variants,
       -> { where(is_master: false).order(:position) },
-      inverse_of: :product,
       class_name: 'Spree::Variant'
 
     has_many :variants_including_master,
@@ -61,6 +60,17 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
+    scope :sort_by_master_default_price_amount_asc, -> {
+      with_default_price.order('spree_prices.amount ASC')
+    }
+    scope :sort_by_master_default_price_amount_desc, -> {
+      with_default_price.order('spree_prices.amount DESC')
+    }
+    scope :with_default_price, -> {
+      left_joins(master: :prices)
+        .where(master: { spree_prices: Spree::Config.default_pricing_options.desired_attributes })
+    }
+
     def find_or_build_master
       master || build_master
     end
@@ -85,6 +95,7 @@ module Spree
              :has_default_price?,
              :images,
              :price_for,
+             :price_for_options,
              :rebuild_vat_prices=,
              to: :find_or_build_master
 

data/app/models/spree/promotion/rules/item_total.rb

@@ -5,12 +5,38 @@ module Spree
     module Rules
       # A rule to apply to an order greater than (or greater than or equal to)
       # a specific amount
+      #
+      # To add extra operators please override `self.operators_map` or any other helper method.
+      # To customize the error message you can also override `ineligible_message`.
       class ItemTotal < PromotionRule
+        include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+
         preference :amount, :decimal, default: 100.00
         preference :currency, :string, default: ->{ Spree::Config[:currency] }
-        preference :operator, :string, default: '>'
+        preference :operator, :string, default: 'gt'
+
+        # The list of allowed operators names mapped to their symbols.
+        def self.operators_map
+          {
+            gte: :>=,
+            gt: :>,
+          }
+        end
+
+        def self.operator_options
+          operators_map.map do |name, _method|
+            [I18n.t(name, scope: 'spree.item_total_rule.operators'), name]
+          end
+        end
 
-        OPERATORS = ['gt', 'gte']
+        # @deprecated
+        OPERATORS = operators_map.keys.map(&:to_s)
+        deprecate_constant(
+          :OPERATORS,
+          :operators_map,
+          message: "OPERATORS is deprecated! Use `operators_map.keys.map(&:to_s)` instead.",
+          deprecator: Spree::Deprecation,
+        )
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -18,8 +44,8 @@ module Spree
 
         def eligible?(order, _options = {})
           return false unless order.currency == preferred_currency
-          item_total = order.item_total
-          unless item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal(preferred_amount.to_s))
+
+          unless total_for_order(order).send(operator, threshold)
             eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
           end
 
@@ -28,15 +54,33 @@ module Spree
 
         private
 
+        def operator
+          self.class.operators_map.fetch(
+            preferred_operator.to_sym,
+            preferred_operator_default,
+          )
+        end
+
+        def total_for_order(order)
+          order.item_total
+        end
+
+        def threshold
+          BigDecimal(preferred_amount.to_s)
+        end
+
         def formatted_amount
           Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
         end
 
         def ineligible_message
-          if preferred_operator == 'gte'
+          case preferred_operator.to_s
+          when 'gte'
             eligibility_error_message(:item_total_less_than, amount: formatted_amount)
-          else
+          when 'gt'
             eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
+          else
+            eligibility_error_message(:item_total_doesnt_match_with_operator, amount: formatted_amount, operator: preferred_operator)
           end
         end
 

data/app/models/spree/promotion.rb

@@ -47,7 +47,7 @@ module Spree
         where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
     end
     scope :has_actions, -> do
-      joins(:promotion_actions)
+      joins(:promotion_actions).distinct
     end
     scope :applied, -> { joins(:order_promotions).distinct }
 
@@ -192,7 +192,7 @@ module Spree
     def usage_count(excluded_orders: [])
       Spree::Adjustment.promotion.
         eligible.
-        in_completed_orders(excluded_orders: excluded_orders).
+        in_completed_orders(excluded_orders: excluded_orders, exclude_canceled: true).
         where(source_id: actions).
         count(:order_id)
     end

data/app/models/spree/promotion_action.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'spree/preferences/persistable'
+
 module Spree
   # Base class for all types of promotion action.
   #
   # PromotionActions perform the necessary tasks when a promotion is activated
   # by an event and determined to be eligible.
   class PromotionAction < Spree::Base
+    include Spree::Preferences::Persistable
     include Spree::SoftDeletable
 
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true

data/app/models/spree/promotion_code.rb

@@ -30,7 +30,7 @@ class Spree::PromotionCode < Spree::Base
   def usage_count(excluded_orders: [])
     adjustments.
     eligible.
-    in_completed_orders(excluded_orders: excluded_orders).
+    in_completed_orders(excluded_orders: excluded_orders, exclude_canceled: true).
     count(:order_id)
   end
 

data/app/models/spree/promotion_rule.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'spree/preferences/persistable'
+
 module Spree
   # Base class for all promotion rules
   class PromotionRule < Spree::Base
+    include Spree::Preferences::Persistable
+
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
     scope :of_type, ->(type) { where(type: type) }

data/app/models/spree/return_item.rb

@@ -254,10 +254,9 @@ module Spree
       }).where.not(id: id).first
 
       if other_return_item && (new_record? || COMPLETED_RECEPTION_STATUSES.include?(reception_status.to_sym))
-        errors.add(:inventory_unit, :other_completed_return_item_exists, {
+        errors.add(:inventory_unit, :other_completed_return_item_exists,
           inventory_unit_id: inventory_unit_id,
-          return_item_id: other_return_item.id
-        })
+          return_item_id: other_return_item.id)
       end
     end
 

data/app/models/spree/shipping_rate_tax.rb

@@ -5,7 +5,7 @@ module Spree
   # @attr [Spree::ShippingRate] shipping_rate The shipping rate to be taxed
   # @attr [Spree::TaxRate] tax_rate The tax rate used to calculate the tax amount
   # @since 1.3.0
-  # @see Spree::Tax::ShippingRateTaxer
+  # @see Spree::Stock::Estimator
   class ShippingRateTax < Spree::Base
     belongs_to :shipping_rate, class_name: "Spree::ShippingRate", optional: true
     belongs_to :tax_rate, class_name: "Spree::TaxRate", optional: true

data/app/models/spree/stock/availability.rb

@@ -19,7 +19,7 @@ module Spree
       # Get the on_hand stock quantities
       # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
       def on_hand_by_stock_location_id
-        counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
+        quantities_by_location_id = counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
           stock_location_id
         end.transform_values do |values|
           Spree::StockQuantities.new(
@@ -31,12 +31,13 @@ module Spree
             end.to_h
           )
         end
+        restore_location_order(quantities_by_location_id)
       end
 
-      # Get the on_hand stock quantities
+      # Get the backorderable stock quantities
       # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
       def backorderable_by_stock_location_id
-        backorderables.group_by(&:second).transform_values do |variant_ids|
+        quantities_by_location_id = backorderables.group_by(&:second).transform_values do |variant_ids|
           Spree::StockQuantities.new(
             variant_ids.map do |variant_id, _|
               variant = @variant_map[variant_id]
@@ -44,6 +45,7 @@ module Spree
             end.to_h
           )
         end
+        restore_location_order(quantities_by_location_id)
       end
 
       private
@@ -67,6 +69,12 @@ module Spree
           where(variant_id: @variants).
           where(stock_location_id: @stock_locations)
       end
+
+      def restore_location_order(quantities_by_location_id)
+        sorted_location_ids = @stock_locations.map(&:id)
+
+        quantities_by_location_id.sort_by { |key, _value| sorted_location_ids.index(key) }.to_h
+      end
     end
   end
 end

data/app/models/spree/stock/simple_coordinator.rb

@@ -73,11 +73,16 @@ module Spree
         packages = split_packages(packages)
 
         # Turn the Stock::Packages into a Shipment with rates
-        packages.map do |package|
+        shipments = packages.map do |package|
           shipment = package.shipment = package.to_shipment
           shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
           shipment
         end
+
+        # Make sure we don't add the proposed shipments to the order
+        order.shipments = order.shipments - shipments
+
+        shipments
       end
 
       def split_packages(initial_packages)
@@ -87,16 +92,6 @@ module Spree
         end
       end
 
-      def sort_availability(availability)
-        sorted_availability = availability.sort_by do |stock_location_id, _|
-          @stock_locations.find_index do |stock_location|
-            stock_location.id == stock_location_id
-          end
-        end
-
-        Hash[sorted_availability]
-      end
-
       def get_units(quantities)
         # Change our raw quantities back into inventory units
         quantities.flat_map do |variant, quantity|

data/app/models/spree/stock_location.rb

@@ -26,7 +26,7 @@ module Spree
     validates_uniqueness_of :code, allow_blank: true, case_sensitive: false
 
     scope :active, -> { where(active: true) }
-    scope :order_default, -> { order(default: :desc, name: :asc) }
+    scope :order_default, -> { order(default: :desc, position: :asc) }
 
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default

data/app/models/spree/store_credit.rb

@@ -150,7 +150,12 @@ class Spree::StoreCredit < Spree::PaymentSource
   end
 
   def generate_authorization_code
-    "#{id}-SC-#{Time.current.utc.strftime('%Y%m%d%H%M%S%6N')}"
+    [
+      id,
+      'SC',
+      Time.current.utc.strftime('%Y%m%d%H%M%S%6N'),
+      SecureRandom.uuid
+    ].join('-')
   end
 
   def editable?

data/app/models/spree/tax_calculator/shipping_rate.rb

@@ -9,7 +9,7 @@ module Spree
     # looking to provide their own calculator should adhere to the API of this
     # class.
     #
-    # @see Spree::Tax::ShippingRateTaxer
+    # @see Spree::Stock::Estimator
     class ShippingRate
       include Spree::Tax::TaxHelpers
 

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

@@ -6,8 +6,8 @@ module Spree::Taxon::ActiveStorageAttachment
 
   included do
     has_attachment :icon,
-                   styles: { mini: '32x32>', normal: '128x128>' },
-                   default_style: :mini
+                   styles: Spree::Config.taxon_image_styles,
+                   default_style: Spree::Config.taxon_image_style_default
     validate :icon_is_an_image
   end
 end

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

@@ -5,14 +5,14 @@ module Spree::Taxon::PaperclipAttachment
 
   included do
     has_attached_file :icon,
-      styles: { mini: '32x32>', normal: '128x128>' },
-      default_style: :mini,
+      styles: Spree::Config.taxon_image_styles,
+      default_style: Spree::Config.taxon_image_style_default,
       url: '/spree/taxons/:id/:style/:basename.:extension',
       path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
       default_url: '/assets/default_taxon.png'
 
     validates_attachment :icon,
-      content_type: { content_type: %w[image/jpg image/jpeg image/png image/gif] }
+      content_type: { content_type: Spree::Config.allowed_image_mime_types }
   end
 
   def icon_present?

data/app/models/spree/variant/price_selector.rb

@@ -26,11 +26,24 @@ module Spree
       # @param [Spree::Variant::PricingOptions] price_options Pricing Options to abide by
       # @return [Spree::Money, nil] The most specific price for this set of pricing options.
       def price_for(price_options)
+        Spree::Deprecation.warn(
+          "price_for is deprecated and will be removed. The price_for method
+          should return a Spree::Price as described. Please use
+          #price_for_options and adjust your frontend code to explicitly call
+          &.money where required"
+        )
+        price_for_options(price_options)&.money
+      end
+
+      # The variant's Spree::Price record, given a set of pricing options
+      # @param [Spree::Variant::PricingOptions] price_options Pricing Options to abide by
+      # @return [Spree::Price, nil] The most specific price for this set of pricing options.
+      def price_for_options(price_options)
         variant.currently_valid_prices.detect do |price|
-          ( price.country_iso == price_options.desired_attributes[:country_iso] ||
-            price.country_iso.nil?
+          (price.country_iso == price_options.desired_attributes[:country_iso] ||
+           price.country_iso.nil?
           ) && price.currency == price_options.desired_attributes[:currency]
-        end.try!(:money)
+        end
       end
     end
   end