solidus_core 2.1.1 → 2.2.0.beta1

data/app/models/spree/payment_create.rb

@@ -5,7 +5,8 @@ module Spree
     # @param attributes [Hash,ActionController::Parameters] attributes which are assigned to the new payment
     #   * :payment_method_id Id of payment method used for this payment
     #   * :source_attributes Attributes used to build the source of this payment. Usually a {CreditCard}
-    #     * :existing_card_id (Integer) The id of an existing {CreditCard} object to use
+    #     * :existing_card_id (Integer) Deprecated: The id of an existing {CreditCard} object to use
+    #     * :wallet_payment_source_id (Integer): The id of a {WalletPaymentSource} to use
     # @param request_env [Hash] rack env of user creating the payment
     # @param payment [Payment] Internal use only. Instead of making a new payment, change the attributes for an existing one.
     def initialize(order, attributes, payment: nil, request_env: {})
@@ -27,7 +28,13 @@ module Spree
       @payment.attributes = @attributes
 
       if source_attributes[:existing_card_id].present?
+        Spree::Deprecation.warn(
+          "Passing existing_card_id to PaymentCreate is deprecated. Use wallet_payment_source_id instead.",
+          caller,
+        )
         build_existing_card
+      elsif source_attributes[:wallet_payment_source_id].present?
+        build_from_wallet_payment_source
       else
         build_source
       end
@@ -44,27 +51,40 @@ module Spree
       if source_attributes.present? && payment_method.try(:payment_source_class)
         payment.source = payment_method.payment_source_class.new(source_attributes)
         payment.source.payment_method_id = payment_method.id
-        payment.source.user_id = order.user_id if order
+        if order && payment.source.respond_to?(:user=)
+          payment.source.user = order.user
+        end
       end
     end
 
+    def build_from_wallet_payment_source
+      wallet_payment_source_id = source_attributes.fetch(:wallet_payment_source_id)
+      raise(ActiveRecord::RecordNotFound) if order.user.nil?
+      wallet_payment_source = order.user.wallet.find(wallet_payment_source_id)
+      raise(ActiveRecord::RecordNotFound) if wallet_payment_source.nil?
+      build_from_payment_source(wallet_payment_source.payment_source)
+    end
+
     def build_existing_card
       credit_card = available_cards.find(source_attributes[:existing_card_id])
+      build_from_payment_source(credit_card)
+    end
 
+    def build_from_payment_source(payment_source)
       # FIXME: does this work?
       if source_attributes[:verification_value]
-        credit_card.verification_value = source_attributes[:verification_value]
+        payment_source.verification_value = source_attributes[:verification_value]
       end
 
-      payment.source = credit_card
-      payment.payment_method_id = credit_card.payment_method_id
+      payment.source = payment_source
+      payment.payment_method_id = payment_source.payment_method_id
     end
 
     def available_cards
       if user_id = order.user_id
-        CreditCard.where(user_id: user_id)
+        Spree::CreditCard.where(user_id: user_id)
       else
-        CreditCard.none
+        Spree::CreditCard.none
       end
     end
   end

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

@@ -109,7 +109,7 @@ module Spree
 
     def handle_action(action, action_name, auth_code)
       # Find first event with provided auth_code
-      store_credit = StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
+      store_credit = Spree::StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
 
       if store_credit.nil?
         ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit.unable_to_find_for_action', auth_code: auth_code, action: action_name), {}, {})
@@ -119,8 +119,8 @@ module Spree
     end
 
     def auth_or_capture_event(auth_code)
-      capture_event = StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::CAPTURE_ACTION)
-      auth_event = StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::AUTHORIZE_ACTION)
+      capture_event = Spree::StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::CAPTURE_ACTION)
+      auth_event = Spree::StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::AUTHORIZE_ACTION)
       capture_event || auth_event
     end
   end

data/app/models/spree/payment_method.rb

@@ -17,7 +17,10 @@ module Spree
     scope :active, -> { where(active: true) }
     scope :available_to_users, -> { where(available_to_users: true) }
     scope :available_to_admin, -> { where(available_to_admin: true) }
-    scope :available_to_store, -> (store) { (store.present? && store.payment_methods.empty?) ? self : store.payment_methods }
+    scope :available_to_store, ->(store) do
+      raise ArgumentError, "You must provide a store" if store.nil?
+      store.payment_methods.empty? ? all : where(id: store.payment_method_ids)
+    end
 
     include Spree::Preferences::StaticallyConfigurable
 

data/app/models/spree/payment_source.rb

@@ -0,0 +1,45 @@
+module Spree
+  class PaymentSource < Spree::Base
+    self.abstract_class = true
+
+    belongs_to :payment_method
+
+    has_many :payments, as: :source
+    has_many :wallet_payment_sources, class_name: 'Spree::WalletPaymentSource', as: :payment_source, inverse_of: :payment_source
+
+    attr_accessor :imported
+
+    # @return [Array<String>] the actions available on this payment source
+    def actions
+      %w(capture void credit)
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be captured
+    # @return [Boolean] true when the payment is in the pending or checkout states
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be voided
+    # @return [Boolean] true when the payment is not failed or voided
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most
+    # gateways require that the payment be settled first which generally
+    # happens within 12-24 hours of the transaction.
+    #
+    # @param payment [Spree::Payment] the payment we want to know if can be credited
+    # @return [Boolean] true when the payment is completed and can be credited
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    # Indicates whether this payment source can be used more than once. E.g. a
+    # credit card with a 'payment profile'.
+    def reusable?
+      false
+    end
+  end
+end

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

@@ -46,12 +46,12 @@ module Spree
     # This scope selects products in taxon AND all its descendants
     # If you need products only within one taxon use
     #
-    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { :id => taxon.id })
+    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
     #
     # If you're using count on the result of this scope, you must use the
     # `:distinct` option as well:
     #
-    #   Spree::Product.in_taxon(taxon).count(:distinct => true)
+    #   Spree::Product.in_taxon(taxon).count(distinct: true)
     #
     # This is so that the count query is distinct'd:
     #
@@ -84,12 +84,12 @@ module Spree
     # note that it can test for properties with NULL values, but not for absent values
     add_search_scope :with_property_value do |property, value|
       joins(:properties)
-        .where("#{ProductProperty.table_name}.value = ?", value)
+        .where("#{Spree::ProductProperty.table_name}.value = ?", value)
         .where(property_conditions(property))
     end
 
     add_search_scope :with_option do |option|
-      option_types = OptionType.table_name
+      option_types = Spree::OptionType.table_name
       conditions = case option
                    when String     then { "#{option_types}.name" => option }
                    when OptionType then { "#{option_types}.id" => option.id }
@@ -100,10 +100,10 @@ module Spree
     end
 
     add_search_scope :with_option_value do |option, value|
-      option_values = OptionValue.table_name
+      option_values = Spree::OptionValue.table_name
       option_type_id = case option
-                       when String then OptionType.find_by(name: option) || option.to_i
-                       when OptionType then option.id
+                       when String then Spree::OptionType.find_by(name: option) || option.to_i
+                       when Spree::OptionType then option.id
         else option.to_i
       end
 
@@ -117,7 +117,7 @@ module Spree
     add_search_scope :with do |value|
       includes(variants_including_master: :option_values).
       includes(:product_properties).
-      where("#{OptionValue.table_name}.name = ? OR #{ProductProperty.table_name}.value = ?", value, value)
+      where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
     end
 
     # Finds all products that have a name containing the given words.
@@ -147,38 +147,38 @@ module Spree
     # there is alternative faster and more elegant solution, it has small drawback though,
     # it doesn stack with other scopes :/
     #
-    # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-    # :order => 'COALESCE(cnt, 0) DESC'
+    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+    # order: 'COALESCE(cnt, 0) DESC'
     add_search_scope :descend_by_popularity do
       joins(:master).
       order(%{
            COALESCE((
              SELECT
-               COUNT(#{LineItem.quoted_table_name}.id)
+               COUNT(#{Spree::LineItem.quoted_table_name}.id)
              FROM
-               #{LineItem.quoted_table_name}
+               #{Spree::LineItem.quoted_table_name}
              JOIN
-               #{Variant.quoted_table_name} AS popular_variants
+               #{Spree::Variant.quoted_table_name} AS popular_variants
              ON
-               popular_variants.id = #{LineItem.quoted_table_name}.variant_id
+               popular_variants.id = #{Spree::LineItem.quoted_table_name}.variant_id
              WHERE
-               popular_variants.product_id = #{Product.quoted_table_name}.id
+               popular_variants.product_id = #{Spree::Product.quoted_table_name}.id
            ), 0) DESC
         })
     end
 
     add_search_scope :not_deleted do
-      where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.current)
+      where("#{Spree::Product.quoted_table_name}.deleted_at IS NULL or #{Spree::Product.quoted_table_name}.deleted_at >= ?", Time.current)
     end
 
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil)
-      joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
+      joins(master: :prices).where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
     end
     search_scopes << :available
 
     add_search_scope :taxons_name_eq do |name|
-      group("spree_products.id").joins(:taxons).where(Taxon.arel_table[:name].eq(name))
+      group("spree_products.id").joins(:taxons).where(Spree::Taxon.arel_table[:name].eq(name))
     end
 
     def self.distinct_by_product_ids(sort_order = nil)
@@ -210,13 +210,13 @@ module Spree
       private
 
       def price_table_name
-        Price.quoted_table_name
+        Spree::Price.quoted_table_name
       end
 
       # specifically avoid having an order for taxon search (conflicts with main order)
       def prepare_taxon_conditions(taxons)
         ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
-        joins(:taxons).where("#{Taxon.table_name}.id" => ids)
+        joins(:taxons).where("#{Spree::Taxon.table_name}.id" => ids)
       end
 
       # Produce an array of keywords for use in scopes.
@@ -228,14 +228,14 @@ module Spree
       end
 
       def get_taxons(*ids_or_records_or_names)
-        taxons = Taxon.table_name
+        taxons = Spree::Taxon.table_name
         ids_or_records_or_names.flatten.map { |t|
           case t
-          when Integer then Taxon.find_by(id: t)
+          when Integer then Spree::Taxon.find_by(id: t)
           when ActiveRecord::Base then t
           when String
-            Taxon.find_by(name: t) ||
-              Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+            Spree::Taxon.find_by(name: t) ||
+              Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
           end
         }.compact.flatten.uniq
       end

data/app/models/spree/product.rb

@@ -91,7 +91,7 @@ module Spree
     validates :name, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
     validates :shipping_category_id, presence: true
-    validates :slug, length: { minimum: 3 }, uniqueness: { allow_blank: true }
+    validates :slug, presence: true, uniqueness: { allow_blank: true }
 
     attr_accessor :option_values_hash
 
@@ -110,7 +110,7 @@ module Spree
 
     # @return [Spree::TaxCategory] tax category for this product, or the default tax category
     def tax_category
-      super || TaxCategory.find_by(is_default: true)
+      super || Spree::TaxCategory.find_by(is_default: true)
     end
 
     # Ensures option_types and product_option_types exist for keys in
@@ -232,8 +232,8 @@ module Spree
     def set_property(property_name, property_value)
       ActiveRecord::Base.transaction do
         # Works around spree_i18n https://github.com/spree/spree/issues/301
-        property = Property.create_with(presentation: property_name).find_or_create_by(name: property_name)
-        product_property = ProductProperty.where(product: self, property: property).first_or_initialize
+        property = Spree::Property.create_with(presentation: property_name).find_or_create_by(name: property_name)
+        product_property = Spree::ProductProperty.where(product: self, property: property).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end

data/app/models/spree/promotion.rb

@@ -19,6 +19,8 @@ module Spree
     has_many :codes, class_name: "Spree::PromotionCode", inverse_of: :promotion, dependent: :destroy
     alias_method :promotion_codes, :codes
 
+    has_many :promotion_code_batches, class_name: "Spree::PromotionCodeBatch", dependent: :destroy
+
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
     validates_associated :rules

data/app/models/spree/promotion_code/batch_builder.rb

@@ -0,0 +1,63 @@
+class ::Spree::PromotionCode::BatchBuilder
+  attr_reader :promotion_code_batch
+  delegate :promotion, :number_of_codes, :base_code, to: :promotion_code_batch
+
+  class_attribute :random_code_length, :batch_size, :sample_characters
+  self.random_code_length = 6
+  self.batch_size = 1_000
+  self.sample_characters = ('a'..'z').to_a + (2..9).to_a.map(&:to_s)
+
+  def initialize(promotion_code_batch)
+    @promotion_code_batch = promotion_code_batch
+  end
+
+  def build_promotion_codes
+    generate_random_codes
+    promotion_code_batch.update!(state: "completed")
+  rescue => e
+    promotion_code_batch.update!(
+      error: e.inspect,
+      state: "failed"
+    )
+    raise e
+  end
+
+  private
+
+  def generate_random_codes
+    total_batches = (number_of_codes.to_f / self.class.batch_size).ceil
+
+    total_batches.times do |i|
+      codes_for_current_batch = Set.new
+      codes_to_generate = [self.class.batch_size, number_of_codes - i * batch_size].min
+
+      while codes_for_current_batch.size < codes_to_generate
+        new_codes = Array.new(codes_to_generate) { generate_random_code }.to_set
+        codes_for_current_batch += get_unique_codes(new_codes)
+      end
+
+      codes_for_current_batch.map do |value|
+        promotion.codes.build(value: value, promotion_code_batch: promotion_code_batch)
+      end
+
+      promotion.save!
+
+      # We have to reload the promotion because otherwise all promotion codes
+      # we are creating will remain in memory. Doing a reload will remove all
+      # codes from memory.
+      promotion.reload
+    end
+  end
+
+  def generate_random_code
+    suffix = Array.new(self.class.random_code_length) do
+      sample_characters.sample
+    end.join
+
+    "#{base_code}_#{suffix}"
+  end
+
+  def get_unique_codes(code_set)
+    code_set - Spree::PromotionCode.where(value: code_set.to_a).pluck(:value)
+  end
+end

data/app/models/spree/promotion_code.rb

@@ -1,5 +1,6 @@
 class Spree::PromotionCode < Spree::Base
   belongs_to :promotion, inverse_of: :codes
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
   has_many :adjustments
 
   validates :value, presence: true, uniqueness: { allow_blank: true }

data/app/models/spree/promotion_code_batch.rb

@@ -0,0 +1,25 @@
+module Spree
+  class PromotionCodeBatch < ActiveRecord::Base
+    class CantProcessStartedBatch < StandardError
+    end
+
+    belongs_to :promotion, class_name: "Spree::Promotion"
+    has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
+
+    validates :number_of_codes, numericality: { greater_than: 0 }
+    validates_presence_of :base_code, :number_of_codes
+
+    def finished?
+      state == "completed"
+    end
+
+    def process
+      if state == "pending"
+        update!(state: "processing")
+        PromotionCodeBatchJob.perform_later(self)
+      else
+        raise CantProcessStartedBatch.new("Batch #{id} already started")
+      end
+    end
+  end
+end

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

@@ -35,13 +35,13 @@ module Spree
       end
 
       def connected_order_promotions
-        Promotion.active.includes(:promotion_rules).
+        Spree::Promotion.active.includes(:promotion_rules).
           joins(:order_promotions).
           where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
       end
 
       def sale_promotions
-        Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
+        Spree::Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
       end
 
       def promotion_code(promotion)

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

@@ -95,8 +95,7 @@ module Spree
         discount ||= order.adjustments.promotion.detect(&detector)
 
         if discount && discount.eligible
-          order.update_totals
-          order.persist_totals
+          order.update!
           set_success_code :coupon_code_applied
         elsif order.promotions.with_coupon_code(order.coupon_code)
           # if the promotion exists on an order, but wasn't found above,

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

@@ -10,38 +10,49 @@ module Spree
       end
 
       def activate
-        promotions.each do |promotion|
-          if order_promotion = existing_order_promotion(promotion)
-            promotion.activate(
-              order: order,
-              promotion_code: order_promotion.promotion_code,
-            )
-          elsif promotion.apply_automatically?
-            promotion.activate(order: order)
-          end
+        connected_promotions.each do |order_promotion|
+          order_promotion.promotion.activate(
+            order: order,
+            promotion_code: order_promotion.promotion_code,
+          )
+        end
+
+        not_connected_automatic_promotions.each do |promotion|
+          promotion.activate(order: order)
         end
       end
 
       private
 
-      def promotions
-        Spree::Promotion.
+      def not_connected_automatic_promotions
+        automatic_promotions - connected_promotions.map(&:promotion)
+      end
+
+      def automatic_promotions
+        @automatic_promotions ||= active_free_shipping_promotions.
+          where(apply_automatically: true).
+          to_a.
+          uniq
+      end
+
+      def connected_promotions
+        @connected_promotions ||= order.order_promotions.
+          joins(:promotion).
+          includes(:promotion).
+          merge(active_free_shipping_promotions).
+          to_a.
+          uniq
+      end
+
+      def active_free_shipping_promotions
+        Spree::Promotion.all.
           active.
           joins(:promotion_actions).
           merge(
             Spree::PromotionAction.of_type(
               Spree::Promotion::Actions::FreeShipping
             )
-          ).
-          distinct
-      end
-
-      def existing_order_promotion(promotion)
-        @lookup ||= order.order_promotions.map do |order_promotion|
-          [order_promotion.promotion_id, order_promotion]
-        end.to_h
-
-        @lookup[promotion.id]
+          )
       end
     end
   end

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

@@ -17,7 +17,7 @@ module Spree
       private
 
       def promotion
-        @promotion ||= Promotion.active.find_by(path: path)
+        @promotion ||= Spree::Promotion.active.find_by(path: path)
       end
     end
   end

data/app/models/spree/reimbursement.rb

@@ -38,7 +38,7 @@ module Spree
     #   Refund.total_amount_reimbursed_for(reimbursement)
     # See the `reimbursement_generator` property regarding the generation of custom reimbursements.
     class_attribute :reimbursement_models
-    self.reimbursement_models = [Refund, Reimbursement::Credit]
+    self.reimbursement_models = [Spree::Refund, Spree::Reimbursement::Credit]
 
     # The reimbursement_performer property should be set to an object that responds to the following methods:
     # - #perform

data/app/models/spree/return_authorization.rb

@@ -13,8 +13,6 @@ module Spree
 
     before_create :generate_number
 
-    after_save :generate_expedited_exchange_reimbursements
-
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
     validates :order, presence: true
@@ -22,11 +20,6 @@ module Spree
     validate :must_have_shipped_units, on: :create
     validate :no_previously_exchanged_inventory_units, on: :create
 
-    # These are called prior to generating expedited exchanges shipments.
-    # Should respond to a "call" method that takes the list of return items
-    class_attribute :pre_expedited_exchange_hooks
-    self.pre_expedited_exchange_hooks = []
-
     state_machine initial: :authorized do
       before_transition to: :canceled, do: :cancel_return_items
 
@@ -88,26 +81,5 @@ module Spree
     def cancel_return_items
       return_items.each { |item| item.cancel! if item.can_cancel? }
     end
-
-    def generate_expedited_exchange_reimbursements
-      return unless Spree::Config[:expedited_exchanges]
-
-      items_to_exchange = return_items.select(&:exchange_required?)
-      items_to_exchange.each(&:attempt_accept)
-      items_to_exchange.select!(&:accepted?)
-
-      return if items_to_exchange.blank?
-
-      pre_expedited_exchange_hooks.each { |h| h.call items_to_exchange }
-
-      reimbursement = Reimbursement.new(return_items: items_to_exchange, order: order)
-
-      if reimbursement.save
-        reimbursement.perform!
-      else
-        errors.add(:base, reimbursement.errors.full_messages)
-        raise ActiveRecord::RecordInvalid.new(self)
-      end
-    end
   end
 end

data/app/models/spree/return_item.rb

@@ -124,7 +124,7 @@ module Spree
         transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
       end
 
-      after_transition any => any, :do => :persist_acceptance_status_errors
+      after_transition any => any, do: :persist_acceptance_status_errors
     end
 
     # @param inventory_unit [Spree::InventoryUnit] the inventory for which we

data/app/models/spree/shipment.rb

@@ -72,7 +72,7 @@ module Spree
     self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
 
-    delegate :tax_category, to: :selected_shipping_rate, allow_nil: true
+    delegate :tax_category, :tax_category_id, to: :selected_shipping_rate, allow_nil: true
 
     def can_transition_from_pending_to_shipped?
       !requires_shipment?
@@ -136,9 +136,9 @@ module Spree
     def finalize!
       transaction do
         pending_units = inventory_units.select(&:pending?)
-        pending_manifest = ShippingManifest.new(inventory_units: pending_units)
+        pending_manifest = Spree::ShippingManifest.new(inventory_units: pending_units)
         pending_manifest.items.each { |item| manifest_unstock(item) }
-        InventoryUnit.finalize_units!(pending_units)
+        Spree::InventoryUnit.finalize_units!(pending_units)
       end
     end
 
@@ -391,7 +391,7 @@ module Spree
     end
 
     def ensure_can_destroy
-      unless pending?
+      if shipped? || canceled?
         errors.add(:state, :cannot_destroy, state: state)
         throw :abort
       end

data/app/models/spree/shipping_method.rb

@@ -34,7 +34,7 @@ module Spree
       # Some extra care is needed with the having clause to ensure we are
       # counting distinct records of the join table. Otherwise a join could
       # cause this to return incorrect results.
-      join_table = ShippingMethodCategory.arel_table
+      join_table = Spree::ShippingMethodCategory.arel_table
       having = join_table[:id].count(true).eq(shipping_category_ids.count)
       joins(:shipping_method_categories).
         where(spree_shipping_method_categories: { shipping_category_id: shipping_category_ids }).
@@ -46,7 +46,7 @@ module Spree
     # @return [ActiveRecord::Relation] shipping methods which are available
     #   with the stock location or are marked available_to_all
     def self.available_in_stock_location(stock_location)
-      smsl_table = ShippingMethodStockLocation.arel_table
+      smsl_table = Spree::ShippingMethodStockLocation.arel_table
 
       # We are searching for either a matching entry in the stock location join
       # table or available_to_all being true.

data/app/models/spree/shipping_rate.rb

@@ -12,7 +12,7 @@ module Spree
              dependent: :destroy
 
     delegate :order, :currency, to: :shipment
-    delegate :name, :tax_category, to: :shipping_method
+    delegate :name, :tax_category, :tax_category_id, to: :shipping_method
     delegate :code, to: :shipping_method, prefix: true
     alias_attribute :amount, :cost