solidus_core 2.8.6 → 2.9.0.rc.1

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

@@ -11,10 +11,10 @@ module Spree
         def eligible?(order, _options = {})
           if order.user.present?
             if promotion.used_by?(order.user, [order])
-              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
+              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user), error_code: :limit_once_per_user)
             end
           else
-            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
           end
 
           eligibility_errors.empty?

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

@@ -33,15 +33,15 @@ module Spree
           case preferred_match_policy
           when 'all'
             unless eligible_products.all? { |p| order.products.include?(p) }
-              eligibility_errors.add(:base, eligibility_error_message(:missing_product))
+              eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
           when 'any'
             unless order.products.any? { |p| eligible_products.include?(p) }
-              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
             end
           when 'none'
             unless order.products.none? { |p| eligible_products.include?(p) }
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
             end
           else
             raise "unexpected match policy: #{preferred_match_policy.inspect}"

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

@@ -27,34 +27,31 @@ module Spree
             end
 
             unless matches_all
-              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
+              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
             end
           when 'any'
             unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons), error_code: :no_matching_taxons)
             end
           when 'none'
             if order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon))
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon), error_code: :has_excluded_taxon)
             end
           else
             # Change this to an exception in a future version of Solidus
             warn_invalid_match_policy(assume: 'any')
             unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons), error_code: :no_matching_taxons)
             end
           end
 
           eligibility_errors.empty?
         end
 
-        # TODO: Fix bug - well described by jhawthorn in #1409:
-        # `eligible?` checks the configured taxons and all descendants,
-        # `actionable?` only seems to check against the taxons themselves (not children)
         def actionable?(line_item)
           found = Spree::Classification.where(
             product_id: line_item.variant.product_id,
-            taxon_id: taxon_ids
+            taxon_id: rule_taxon_ids_with_children
           ).exists?
 
           case preferred_match_policy

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

@@ -10,7 +10,7 @@ module Spree
 
         def eligible?(order, _options = {})
           unless order.user.present?
-            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
           end
           eligibility_errors.empty?
         end

data/app/models/spree/promotion_handler/coupon.rb

@@ -44,9 +44,9 @@ module Spree
         @success = I18n.t(status_code, scope: 'spree')
       end
 
-      def set_error_code(status_code)
+      def set_error_code(status_code, options = {})
         @status_code = status_code
-        @error = I18n.t(status_code, scope: 'spree')
+        @error = options[:error] || I18n.t(status_code, scope: 'spree')
       end
 
       def promotion
@@ -72,7 +72,7 @@ module Spree
         return promotion_applied if promotion_exists_on_order?(order, promotion)
 
         unless promotion.eligible?(order, promotion_code: promotion_code)
-          self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
+          set_promotion_eligibility_error_code(promotion)
           return (error || ineligible_for_this_order)
         end
 
@@ -87,6 +87,15 @@ module Spree
         end
       end
 
+      def set_promotion_eligibility_error_code(promotion)
+        return unless eligibility_error_code_present?(promotion)
+
+        eligibility_error = promotion.eligibility_errors.details[:base].first
+
+        @status_code = eligibility_error[:error_code]
+        @error = eligibility_error[:error]
+      end
+
       def promotion_usage_limit_exceeded
         set_error_code :coupon_code_max_usage
       end
@@ -102,6 +111,13 @@ module Spree
       def promotion_exists_on_order?(order, promotion)
         order.promotions.include? promotion
       end
+
+      def eligibility_error_code_present?(promotion)
+        promotion.eligibility_errors.present? &&
+          promotion.eligibility_errors.details.present? &&
+          promotion.eligibility_errors.details.key?(:base) &&
+          promotion.eligibility_errors.details[:base].first[:error_code].present?
+      end
     end
   end
 end

data/app/models/spree/property.rb

@@ -11,6 +11,8 @@ module Spree
 
     after_touch :touch_all_products
 
+    self.whitelisted_ransackable_attributes = %w[name]
+
     private
 
     def touch_all_products

data/app/models/spree/reimbursement.rb

@@ -111,11 +111,15 @@ module Spree
 
       if unpaid_amount_within_tolerance?
         reimbursed!
+        Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
         reimbursement_success_hooks.each { |h| h.call self }
-        send_reimbursement_email
       else
         errored!
+        Spree::Event.fire 'reimbursement_errored', reimbursement: self
         reimbursement_failure_hooks.each { |h| h.call self }
+      end
+
+      if errored?
         raise IncompleteReimbursementError, I18n.t("spree.validation.unpaid_amount_not_zero", amount: unpaid_amount)
       end
     end
@@ -176,10 +180,6 @@ module Spree
       end
     end
 
-    def send_reimbursement_email
-      Spree::Config.reimbursement_mailer_class.reimbursement_email(id).deliver_later
-    end
-
     # If there are multiple different reimbursement types for a single
     # reimbursement we open ourselves to a one-cent rounding error for every
     # type over the first one. This is due to how we round #unpaid_amount and

data/app/models/spree/return_item.rb

@@ -130,6 +130,8 @@ module Spree
       after_transition any => any, do: :persist_acceptance_status_errors
     end
 
+    attr_accessor :skip_customer_return_processing
+
     # @param inventory_unit [Spree::InventoryUnit] the inventory for which we
     #   want a return item
     # @return [Spree::ReturnItem] a valid return item for the given inventory
@@ -233,10 +235,12 @@ module Spree
 
     def process_inventory_unit!
       inventory_unit.return!
-
       if customer_return
         customer_return.stock_location.restock(inventory_unit.variant, 1, customer_return) if should_restock?
-        customer_return.process_return!
+        unless skip_customer_return_processing
+          Deprecation.warn 'From Solidus v2.9 onwards, #process_inventory_unit! will not call customer_return#process_return!'
+          customer_return.process_return!
+        end
       end
     end
 

data/app/models/spree/state.rb

@@ -19,6 +19,8 @@ module Spree
       deprecate find_all_by_name_or_abbr: :with_name_or_abbr, deprecator: Spree::Deprecation
     end
 
+    self.whitelisted_ransackable_attributes = %w[name]
+
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
@@ -36,5 +38,9 @@ module Spree
     def to_s
       name
     end
+
+    def state_with_country
+      "#{name} (#{country})"
+    end
   end
 end

data/app/models/spree/stock/location_filter/active.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module LocationFilter
+      # This stock location filter return all active stock locations
+      class Active < Spree::Stock::LocationFilter::Base
+        def filter
+          stock_locations.active
+        end
+      end
+    end
+  end
+end

data/app/models/spree/stock/location_filter/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module LocationFilter
+      # Stock location filters are used to which stock location should be
+      # considered when allocating stocks for a new shipment
+      #
+      # @abstract To implement your own location filter, subclass and
+      #   implement {#filter}.
+      class Base
+        # @!attribute [r] stock_locations
+        #   @return [Enumerable<Spree::StockLocation>]
+        #     a collection of locations to sort
+        attr_reader :stock_locations
+
+        # @!attribute [r] order
+        #   @return <Spree::Order>
+        #     the order we are creating the shipment for
+        attr_reader :order
+
+        # Initializes the stock location filter.
+        #
+        # @param stock_locations [Enumerable<Spree::StockLocation>]
+        #   a collection of locations to sort
+        # @param order <Spree::Order>
+        #   the order we are creating the shipment for
+        def initialize(stock_locations, order)
+          @stock_locations = stock_locations
+          @order = order
+        end
+
+        # Filter the stock locations.
+        #
+        # @return [Enumerable<Spree::StockLocation>]
+        #   a collection of filtered stock locations
+        def filter
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,10 @@ module Spree
         @order = order
         @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
         @splitters = Spree::Config.environment.stock_splitters
-        @stock_locations = Spree::Config.stock.location_sorter_class.new(Spree::StockLocation.active).sort
+
+        filtered_stock_locations = Spree::Config.stock.location_filter_class.new(Spree::StockLocation.all, @order).filter
+        sorted_stock_locations = Spree::Config.stock.location_sorter_class.new(filtered_stock_locations).sort
+        @stock_locations = sorted_stock_locations
 
         @inventory_units_by_variant = @inventory_units.group_by(&:variant)
         @desired = Spree::StockQuantities.new(@inventory_units_by_variant.transform_values(&:count))

data/app/models/spree/stock_location.rb

@@ -31,6 +31,8 @@ module Spree
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
 
+    self.whitelisted_ransackable_attributes = %w[name]
+
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
     end

data/app/models/spree/tax_category.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
+require 'discard'
+
 module Spree
   class TaxCategory < Spree::Base
     acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    after_discard do
+      self.tax_rate_tax_categories = []
+    end
+
     validates :name, presence: true
     validates_uniqueness_of :name, unless: :deleted_at
 

data/app/models/spree/taxon.rb

@@ -25,15 +25,9 @@ module Spree
     after_save :touch_ancestors_and_taxonomy
     after_touch :touch_ancestors_and_taxonomy
 
-    has_attached_file :icon,
-      styles: { mini: '32x32>', normal: '128x128>' },
-      default_style: :mini,
-      url: '/spree/taxons/:id/:style/:basename.:extension',
-      path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
-      default_url: '/assets/default_taxon.png'
+    include ::Spree::Config.taxon_attachment_module
 
-    validates_attachment :icon,
-      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png", "image/gif"] }
+    self.whitelisted_ransackable_attributes = %w[name]
 
     # @note This method is meant to be overridden on a store by store basis.
     # @return [Array] filters that should be used for a taxon
@@ -59,9 +53,8 @@ module Spree
     # Sets this taxons permalink to a valid url encoded string based on its
     # name and its parents permalink (if present.)
     def set_permalink
-      permalink_tail = permalink.split('/').last if permalink.present?
-      permalink_tail ||= Spree::Config.taxon_url_parametizer_class.parameterize(name)
-      self.permalink_part = permalink_tail
+      permalink_tail = permalink.present? ? permalink.split('/').last : name
+      self.permalink_part = Spree::Config.taxon_url_parametizer_class.parameterize(permalink_tail)
     end
 
     # Update the permalink for this taxon and all children (if necessary)

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree::Taxon::PaperclipAttachment
+  extend ActiveSupport::Concern
+
+  included do
+    has_attached_file :icon,
+      styles: { mini: '32x32>', normal: '128x128>' },
+      default_style: :mini,
+      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] }
+  end
+
+  def icon_present?
+    icon.present?
+  end
+end

data/app/models/spree/taxonomy.rb

@@ -13,6 +13,8 @@ module Spree
 
     default_scope -> { order(position: :asc) }
 
+    self.whitelisted_ransackable_attributes = %w[name]
+
     private
 
     def set_name

data/app/models/spree/unit_cancel.rb

@@ -34,6 +34,17 @@ class Spree::UnitCancel < Spree::Base
   # This method is used by Adjustment#update to recalculate the cost.
   def compute_amount(line_item)
     raise "Adjustable does not match line item" unless line_item == inventory_unit.line_item
-    -(line_item.total.to_d / line_item.inventory_units.not_canceled.reject(&:original_return_item ).size)
+
+    -weighted_line_item_amount(line_item)
+  end
+
+  private
+
+  def weighted_line_item_amount(line_item)
+    line_item.total_before_tax / quantity_of_line_item(line_item)
+  end
+
+  def quantity_of_line_item(line_item)
+    BigDecimal(line_item.inventory_units.not_canceled.reject(&:original_return_item).size)
   end
 end

data/app/models/spree/variant.rb

@@ -121,7 +121,7 @@ module Spree
         Spree::StockItem.arel_table[:count_on_hand].gt(0),
         Spree::StockItem.arel_table[:backorderable].eq(true)
       ]
-      joins(:stock_items).where(arel_conditions.inject(:or))
+      joins(:stock_items).where(arel_conditions.inject(:or)).distinct
     end
 
     self.whitelisted_ransackable_associations = %w[option_values product prices default_price]

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

@@ -49,6 +49,16 @@ module Spree
         new(currency: price.currency, country_iso: price.country_iso)
       end
 
+      # This creates the correct pricing options for a price, so the store owners can easily customize how to
+      # find the pricing based on the view context, having available current_store, current_spree_user, request.host_name, etc.
+      # @return [Spree::Variant::PricingOptions] pricing options for pricing a line item
+      def self.from_context(context)
+        new(
+          currency: context.current_store.try!(:default_currency).presence || Spree::Config[:currency],
+          country_iso: context.current_store.try!(:cart_tax_country_iso).presence
+        )
+      end
+
       # @return [Hash] The hash of exact desired attributes
       attr_reader :desired_attributes
 

data/app/models/spree/wallet_payment_source.rb

@@ -1,19 +1,35 @@
 # frozen_string_literal: true
 
-class Spree::WalletPaymentSource < ActiveRecord::Base
-  belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: 'user_id', inverse_of: :wallet_payment_sources
-  belongs_to :payment_source, polymorphic: true, inverse_of: :wallet_payment_sources
+module Spree
+  class WalletPaymentSource < Spree::Base
+    belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: 'user_id', inverse_of: :wallet_payment_sources
+    belongs_to :payment_source, polymorphic: true, inverse_of: :wallet_payment_sources
 
-  validates_presence_of :user
-  validates_presence_of :payment_source
+    validates_presence_of :user
+    validates_presence_of :payment_source
+    validates :user_id, uniqueness: {
+      scope: [:payment_source_type, :payment_source_id],
+      message: :payment_source_already_exists
+    }
 
-  validate :check_for_payment_source_class
+    validate :check_for_payment_source_class
+    validate :validate_payment_source_ownership
 
-  private
+    private
 
-  def check_for_payment_source_class
-    if !payment_source.is_a?(Spree::PaymentSource)
-      errors.add(:payment_source, :has_to_be_payment_source_class)
+    def check_for_payment_source_class
+      if !payment_source.is_a?(Spree::PaymentSource)
+        errors.add(:payment_source, :has_to_be_payment_source_class)
+      end
+    end
+
+    def validate_payment_source_ownership
+      return unless payment_source.present?
+
+      if payment_source.respond_to?(:user_id) &&
+         payment_source.user_id != user_id
+        errors.add(:payment_source, :not_owned_by_user)
+      end
     end
   end
 end