spree_core 5.4.0.beta → 5.4.0.beta3

data/app/models/spree/payment_response.rb

@@ -0,0 +1,70 @@
+module Spree
+  # Lightweight value object representing a payment gateway response.
+  #
+  # This is Spree's native replacement for +ActiveMerchant::Billing::Response+.
+  # It carries the same interface so existing payment method implementations
+  # (Bogus, Check, StoreCredit, and third-party gateways) can return it without
+  # any callers needing to change.
+  #
+  # @example Successful authorization
+  #   Spree::PaymentResponse.new(true, 'Transaction approved', {},
+  #     authorization: 'ch_abc123',
+  #     avs_result:    { code: 'D' },
+  #     cvv_result:    { code: 'M', message: 'Match' },
+  #     test:          true)
+  #
+  # @example Failed charge
+  #   Spree::PaymentResponse.new(false, 'Card declined', { message: 'Insufficient funds' })
+  #
+  class PaymentResponse
+    # @return [HashWithIndifferentAccess] raw gateway params
+    attr_reader :params
+
+    # @return [String] human-readable result message
+    attr_reader :message
+
+    # @return [Boolean] whether the response came from a test/sandbox environment
+    attr_reader :test
+
+    # @return [String, nil] gateway authorization / transaction reference
+    attr_reader :authorization
+
+    # @return [Hash] AVS (Address Verification System) result with +"code"+ key
+    attr_reader :avs_result
+
+    # @return [Hash] CVV result with +"code"+ and +"message"+ keys
+    attr_reader :cvv_result
+
+    # @param success [Boolean] whether the gateway action succeeded
+    # @param message [String]  human-readable result message
+    # @param params  [Hash]    raw key/value pairs returned by the gateway
+    # @param options [Hash]    additional metadata
+    # @option options [String]  :authorization  gateway transaction reference
+    # @option options [Hash]    :avs_result     must contain +:code+
+    # @option options [Hash]    :cvv_result     may contain +:code+ and +:message+
+    # @option options [Boolean] :test           sandbox/test flag
+    def initialize(success, message, params = {}, options = {})
+      @success = success
+      @message = message
+      @params = params.with_indifferent_access
+      @test = options[:test] || false
+      @authorization = options[:authorization]
+      @avs_result = options[:avs_result] ? { 'code' => options[:avs_result][:code] } : { 'code' => nil }
+      @cvv_result = if options[:cvv_result]
+                      { 'code' => options[:cvv_result][:code], 'message' => options[:cvv_result][:message] }
+                    else
+                      { 'code' => nil, 'message' => nil }
+                    end
+    end
+
+    # @return [Boolean] whether the gateway action succeeded
+    def success?
+      @success
+    end
+
+    # @return [Boolean] whether the response came from a test/sandbox environment
+    def test?
+      @test
+    end
+  end
+end

data/app/models/spree/permission_sets/default_customer.rb

@@ -15,8 +15,6 @@ module Spree
         can :read, Spree::OptionType
         can :read, Spree::OptionValue
         can :read, Spree::Product
-        can :read, Spree::ProductProperty
-        can :read, Spree::Property
         can :read, Spree::State
         can :read, Spree::Store
         can :read, Spree::Taxon
@@ -26,9 +24,6 @@ module Spree
 
         # Content pages
         can :read, Spree::Policy
-        can :read, Spree::Page if defined?(Spree::Page)
-        can :read, Spree::Post if defined?(Spree::Post)
-        can :read, Spree::PostCategory if defined?(Spree::PostCategory)
 
         # Order management for the user's own orders
         can :create, Spree::Order

data/app/models/spree/permission_sets/product_display.rb

@@ -14,8 +14,6 @@ module Spree
         can [:read, :admin], Spree::Variant
         can [:read, :admin], Spree::OptionType
         can [:read, :admin], Spree::OptionValue
-        can [:read, :admin], Spree::Property
-        can [:read, :admin], Spree::ProductProperty
         can [:read, :admin], Spree::Metafield
         can [:read, :admin], Spree::Taxon
         can [:read, :admin], Spree::Taxonomy

data/app/models/spree/permission_sets/product_management.rb

@@ -14,8 +14,6 @@ module Spree
         can :manage, Spree::Variant
         can :manage, Spree::OptionType
         can :manage, Spree::OptionValue
-        can :manage, Spree::Property
-        can :manage, Spree::ProductProperty
         can :manage, Spree::Taxon
         can :manage, Spree::Taxonomy
         can :manage, Spree::Classification

data/app/models/spree/product.rb

@@ -72,9 +72,6 @@ module Spree
 
     has_many :product_option_types, -> { order(:position) }, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
-    has_many :product_properties, dependent: :destroy, inverse_of: :product
-    has_many :properties, through: :product_properties
-
     has_many :classifications, -> { order(created_at: :asc) }, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
     has_many :taxonomies, through: :taxons
@@ -200,24 +197,9 @@ module Spree
     scope :by_source, ->(source) { send(source) }
     scope :paused, -> { where(status: 'paused') }
     scope :published, -> { where(status: 'active') }
-    scope :in_stock_items, -> { joins(:variants).merge(Spree::Variant.in_stock_or_backorderable) }
-    scope :out_of_stock_items, lambda {
-      joins(variants_including_master: :stock_items).
-        where(spree_variants: { track_inventory: true }).
-        where.not(id: Spree::Variant.where(track_inventory: false).pluck(:product_id).uniq).
-        where(spree_stock_items: { backorderable: false }).
-        group(:id).
-        having("SUM(#{Spree::StockItem.table_name}.count_on_hand) <= 0")
-    }
-    scope :out_of_stock, lambda {
-                           joins(:stock_items).where("#{Spree::Variant.table_name}.track_inventory = ? OR #{Spree::StockItem.table_name}.count_on_hand <= ?", false, 0)
-                         }
 
     attr_accessor :option_values_hash
 
-    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp|
-                                                                                         pp[:property_id].blank? || (pp[:id].blank? && pp[:value].blank?)
-                                                                                       }
     accepts_nested_attributes_for(
       :variants,
       allow_destroy: true,
@@ -236,9 +218,9 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at]
     self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants tags labels
-                                                   shipping_category classifications option_types properties]
+                                                   shipping_category classifications option_types]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between
-                                             multi_search in_stock_items out_of_stock_items with_option_value_ids
+                                             multi_search in_stock out_of_stock with_option_value_ids
                                              ascend_by_price descend_by_price]
 
     [
@@ -417,7 +399,7 @@ module Spree
     # Returns the short description for the product
     # @return [String]
     def storefront_description
-      property('short_description') || description
+      description
     end
 
     # Returns tax category for Product
@@ -479,13 +461,6 @@ module Spree
       Products::Duplicator.call(product: self)
     end
 
-    # use deleted? rather than checking the attribute directly. this
-    # allows extensions to override deleted? if they want to provide
-    # their own definition.
-    def deleted?
-      !!deleted_at
-    end
-
     # determine if product is available.
     # deleted products and products with status different than active
     # are not available
@@ -513,14 +488,6 @@ module Spree
       variants_including_master.any?(&:backordered?)
     end
 
-    # split variants list into hash which shows mapping of opt value onto matching variants
-    # eg categorise_variants_from_option(color) => {"red" -> [...], "blue" -> [...]}
-    def categorise_variants_from_option(opt_type)
-      return {} unless option_types.include?(opt_type)
-
-      variants.active.group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
-    end
-
     def self.like_any(fields, values)
       conditions = fields.product(values).map do |(field, value)|
         arel_table[field].matches("%#{value}%")
@@ -537,48 +504,6 @@ module Spree
       variants.active(current_currency).joins(:option_value_variants)
     end
 
-    def empty_option_values?
-      options.empty? || options.any? do |opt|
-        opt.option_type.option_values.empty?
-      end
-    end
-
-    def property(property_name)
-      if product_properties.loaded?
-        product_properties.detect { |property| property.property.name == property_name }.try(:value)
-      else
-        product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
-      end
-    end
-
-    def set_property(property_name, property_value, property_presentation = property_name)
-      property_name = property_name.to_s.parameterize
-      ApplicationRecord.transaction do
-        # Manual first_or_create to work around Mobility bug
-        property = if Property.where(name: property_name).exists?
-                     existing_property = Property.where(name: property_name).first
-                     existing_property.presentation ||= property_presentation
-                     existing_property.save
-                     existing_property
-                   else
-                     Property.create(name: property_name, presentation: property_presentation)
-                   end
-
-        product_property = if ProductProperty.where(product: self, property: property).exists?
-                             ProductProperty.where(product: self, property: property).first
-                           else
-                             ProductProperty.new(product: self, property: property)
-                           end
-
-        product_property.value = property_value
-        product_property.save!
-      end
-    end
-
-    def remove_property(property_name)
-      product_properties.joins(:property).find_by(spree_properties: { name: property_name.parameterize })&.destroy
-    end
-
     def total_on_hand
       @total_on_hand ||= if any_variants_not_track_inventory?
                            BigDecimal::INFINITY
@@ -668,9 +593,7 @@ module Spree
     def taxons_for_store(store)
       return if classification_count.zero?
 
-      Rails.cache.fetch("#{cache_key_with_version}/taxons-per-store/#{store.id}") do
-        taxons.loaded? ? taxons.find_all { |taxon| taxon.taxonomy.store_id == store.id } : taxons.for_store(store)
-      end
+      taxons.loaded? ? taxons.find_all { |taxon| taxon.taxonomy.store_id == store.id } : taxons.for_store(store)
     end
 
     def any_variant_in_stock_or_backorderable?
@@ -702,7 +625,7 @@ module Spree
 
     def to_csv(store = nil)
       store ||= stores.default || stores.first
-      properties_for_csv = if Spree::Config[:product_properties_enabled]
+      properties_for_csv = if respond_to?(:product_properties) && Spree::Config.respond_to?(:product_properties_enabled) && Spree::Config[:product_properties_enabled]
                              Spree::Property.order(:position).flat_map do |property|
                                [
                                  property.name,
@@ -746,9 +669,6 @@ module Spree
 
     def add_associations_from_prototype
       if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
-        prototype.properties.each do |property|
-          product_properties.create(property: property, value: 'Placeholder')
-        end
         self.option_types = prototype.option_types
         self.taxons = prototype.taxons
       end

data/app/models/spree/promotion.rb

@@ -190,26 +190,14 @@ module Spree
       !!eligible_rules(promotable, options)
     end
 
-    # We cache the rules to avoid multiple database queries
-    # this is useful for orders with many line items
-    #
-    # @return [Array<Spree::PromotionRule>]
-    def cached_rules
-      Rails.cache.fetch("#{cache_key_with_version}/rules") do
-        rules.to_a
-      end
-    rescue TypeError # when using null_store in test environment
-      rules.to_a
-    end
-
     # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
     # if there are no such rules, an empty array is returned
     # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
-      return [] if cached_rules.none?
+      return [] if rules.none?
 
-      specific_rules = cached_rules.select { |rule| rule.applicable?(promotable) }
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
       return [] if specific_rules.none?
 
       rule_eligibility = Hash[specific_rules.map do |rule|

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

@@ -177,8 +177,8 @@ module Spree
 
         # Check for applied adjustments.
         discount = order.all_adjustments.promotion.eligible.detect do |p|
-          p.cached_source.promotion.code.try(:downcase) == coupon_code ||
-            Spree::CouponCode.unused.where(promotion_id: p.cached_source.promotion_id, code: coupon_code).exists?
+          p.source.promotion.code.try(:downcase) == coupon_code ||
+            Spree::CouponCode.unused.where(promotion_id: p.source.promotion_id, code: coupon_code).exists?
         end
 
         # Check for applied line items.
@@ -209,7 +209,7 @@ module Spree
       end
 
       def handle_coupon_code(discount, coupon_code)
-        Spree::CouponCode.unused.find_by(promotion_id: discount.cached_source.promotion_id, code: coupon_code)&.apply_order!(order)
+        Spree::CouponCode.unused.find_by(promotion_id: discount.source.promotion_id, code: coupon_code)&.apply_order!(order)
       end
 
       def load_gift_card_code

data/app/models/spree/prototype.rb

@@ -4,9 +4,6 @@ module Spree
 
     include Spree::Metadata
 
-    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
-    has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
-
     has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
     has_many :option_types, through: :option_type_prototypes, class_name: 'Spree::OptionType'
 

data/app/models/spree/refund.rb

@@ -36,6 +36,10 @@ module Spree
 
     delegate :order, :currency, to: :payment
 
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
     def money
       Spree::Money.new(amount, currency: currency)
     end
@@ -83,7 +87,7 @@ module Spree
       update_order
     end
 
-    # return an activemerchant response object if successful or else raise an error
+    # return a payment response object if successful or else raise an error
     def process!(credit_cents)
       refund_total_in_cents = calculate_refund_amount(credit_cents)
 
@@ -102,7 +106,7 @@ module Spree
       end
 
       response
-    rescue ActiveMerchant::ConnectionError => e
+    rescue Spree::PaymentConnectionError => e
       Rails.logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
       raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end

data/app/models/spree/reimbursement.rb

@@ -4,7 +4,6 @@ module Spree
 
     include Spree::Core::NumberGenerator.new(prefix: 'RI', length: 9)
     include Spree::NumberIdentifier
-    include Spree::Reimbursement::Emails
 
     class IncompleteReimbursementError < StandardError; end
 
@@ -116,7 +115,6 @@ module Spree
       if unpaid_amount_within_tolerance?
         reimbursed!
         reimbursement_success_hooks.each { |h| h.call self }
-        send_reimbursement_email
       else
         errored!
         reimbursement_failure_hooks.each { |h| h.call self }

data/app/models/spree/shipment.rb

@@ -14,7 +14,6 @@ module Spree
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
     end
-    include Spree::Shipment::Emails
     include Spree::Shipment::Webhooks
     include Spree::Shipment::CustomEvents
 

data/app/models/spree/shipment_handler.rb

@@ -1,6 +1,5 @@
 module Spree
   class ShipmentHandler
-    include Spree::Shipment::Emails
     include Spree::IntegrationsConcern
 
     class << self
@@ -25,7 +24,6 @@ module Spree
       @shipment.process_order_payments if Spree::Config[:auto_capture_on_dispatch]
       @shipment.touch :shipped_at
       update_order_shipment_state
-      send_shipped_email
     end
 
     protected

data/app/models/spree/shipping_category.rb

@@ -16,10 +16,10 @@ module Spree
       find_by(name: DIGITAL_NAME)
     end
 
+    # Returns true if this shipping category includes a digital shipping method
+    # @return [Boolean]
     def includes_digital_shipping_method?
-      Rails.cache.fetch("#{cache_key_with_version}/includes-digital-shipping-method") do
-        shipping_methods.digital.exists?
-      end
+      @includes_digital_shipping_method ||= shipping_methods.digital.exists?
     end
   end
 end

data/app/models/spree/store.rb

@@ -75,7 +75,6 @@ module Spree
 
     has_many :store_products, class_name: 'Spree::StoreProduct'
     has_many :products, through: :store_products, class_name: 'Spree::Product'
-    has_many :product_properties, through: :products, class_name: 'Spree::ProductProperty'
     has_many :variants, through: :products, class_name: 'Spree::Variant', source: :variants_including_master
     has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
     has_many :inventory_units, through: :variants, class_name: 'Spree::InventoryUnit'
@@ -93,17 +92,12 @@ module Spree
 
     has_many :wishlists, class_name: 'Spree::Wishlist'
 
-    has_many :data_feeds, class_name: 'Spree::DataFeed'
-
     belongs_to :default_country, class_name: 'Spree::Country'
     belongs_to :checkout_zone, class_name: 'Spree::Zone'
 
     has_many :reports, class_name: 'Spree::Report'
     has_many :exports, class_name: 'Spree::Export'
 
-    has_many :posts, class_name: 'Spree::Post', dependent: :destroy, inverse_of: :store
-    has_many :post_categories, class_name: 'Spree::PostCategory', dependent: :destroy, inverse_of: :store
-
     has_many :integrations, class_name: 'Spree::Integration'
 
     has_many :gift_cards, class_name: 'Spree::GiftCard', dependent: :destroy
@@ -165,9 +159,7 @@ module Spree
     after_create :ensure_default_market
     after_create :ensure_default_taxonomies_are_created
     after_create :ensure_default_automatic_taxons
-    after_create :ensure_default_post_categories_are_created
     after_create :create_default_policies
-    after_commit :clear_cache
 
     #
     # Scopes
@@ -184,17 +176,15 @@ module Spree
 
     # @deprecated The or_initialize behavior will be removed in Spree 5.5.
     def self.default
-      Rails.cache.fetch('default_store') do
-        # workaround for Mobility bug with first_or_initialize
-        if where(default: true).any?
-          where(default: true).first
-        else
-          Spree::Deprecation.warn(
-            'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
-            'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
-          )
-          new(default: true)
-        end
+      # workaround for Mobility bug with first_or_initialize
+      if where(default: true).any?
+        where(default: true).first
+      else
+        Spree::Deprecation.warn(
+          'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
+          'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
+        )
+        new(default: true)
       end
     end
 
@@ -296,9 +286,7 @@ module Spree
     # @param country [Spree::Country] the country to get the states for
     # @return [Array<Spree::State>]
     def states_available_for_checkout(country)
-      Rails.cache.fetch(states_available_for_checkout_cache_key(country)) do
-        country.states.to_a
-      end
+      country.states.to_a
     end
 
     # @deprecated Use {Spree::Zone.all} or {#countries_with_shipping_coverage} instead.
@@ -388,18 +376,6 @@ module Spree
 
     private
 
-    def countries_available_for_checkout_cache_key
-      "#{cache_key_with_version}/countries_available_for_checkout"
-    end
-
-    def states_available_for_checkout_cache_key(country)
-      "#{cache_key_with_version}/states_available_for_checkout/#{country&.cache_key_with_version}"
-    end
-
-    def clear_cache
-      Rails.cache.delete('default_store')
-    end
-
     def ensure_default_market
       return if markets.exists?
 
@@ -463,21 +439,6 @@ module Spree
       end
     end
 
-    def ensure_default_post_categories_are_created
-      Spree::Events.disable do
-        [
-          translate_with_store_locale_fallback('spree.default_post_categories.resources'),
-          translate_with_store_locale_fallback('spree.default_post_categories.articles'),
-          translate_with_store_locale_fallback('spree.default_post_categories.news')
-        ].each do |category_title|
-          # Use exists?/create pattern for safety
-          next if post_categories.where(title: category_title).exists?
-
-          post_categories.create(title: category_title)
-        end
-      end
-    end
-
     def create_default_policies
       Spree::Events.disable do
         [

data/app/models/spree/store_credit.rb

@@ -54,6 +54,10 @@ module Spree
     extend Spree::DisplayMoney
     money_methods :amount, :amount_used, :amount_remaining, :amount_authorized
 
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
     self.whitelisted_ransackable_attributes = %w[user_id created_by_id amount currency type_id]
     self.whitelisted_ransackable_associations = %w[type user created_by]
 

data/app/models/spree/tax_category.rb

@@ -10,15 +10,11 @@ module Spree
     has_many :variants, dependent: :nullify
 
     before_save :set_default_category
-    after_update :delete_cache
-    after_create :delete_cache
 
     self.whitelisted_ransackable_attributes = %w[name is_default tax_code]
 
     def self.default
-      Rails.cache.fetch('default_tax_category') do
-        find_by(is_default: true)
-      end
+      find_by(is_default: true)
     end
 
     def set_default_category
@@ -28,11 +24,5 @@ module Spree
         tax_category.update_columns(is_default: false, updated_at: Time.current)
       end
     end
-
-    private
-
-    def delete_cache
-      Rails.cache.delete('default_tax_category')
-    end
   end
 end

data/app/models/spree/taxon.rb

@@ -38,8 +38,6 @@ module Spree
     has_one :store, through: :taxonomy
     has_many :classifications, -> { order(:position) }, dependent: :destroy_async, inverse_of: :taxon
     has_many :products, through: :classifications
-    # @deprecated Use Spree::Taxon#image (Active Storage) instead. Will be removed in Spree 5.5.
-    has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage'
 
     has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
@@ -60,7 +58,6 @@ module Spree
     validates :taxonomy, presence: true
     validates :permalink, uniqueness: { case_sensitive: false, scope: [:parent_id, :taxonomy_id] }
     validates :hide_from_nav, inclusion: { in: [true, false] }
-    validates_associated :icon
     validate :check_for_root, on: :create
     validate :parent_belongs_to_same_taxonomy
     with_options length: { maximum: 255 }, allow_blank: true do
@@ -312,19 +309,6 @@ module Spree
       end
     end
 
-    # indicate which filters should be used for a taxon
-    # this method should be customized to your own site
-    def applicable_filters
-      Spree::Deprecation.warn('applicable_filters is deprecated and will be removed in Spree 5.5')
-      fs = []
-      # fs << ProductFilters.taxons_below(self)
-      ## unless it's a root taxon? left open for demo purposes
-
-      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
-      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
-      fs
-    end
-
     # Return meta_title if set otherwise generates from taxon name
     def seo_title
       meta_title.blank? ? name : meta_title