spree_core 5.3.4 → 5.4.0.beta2

data/app/models/spree/payment_setup_session.rb

@@ -0,0 +1,79 @@
+module Spree
+  class PaymentSetupSession < Spree.base_class
+    has_prefix_id :pss
+
+    acts_as_paranoid
+
+    include Spree::Metafields
+
+    self.event_prefix = 'payment_setup_session'
+
+    publishes_lifecycle_events
+
+    belongs_to :customer, class_name: Spree.user_class.to_s, optional: true
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    belongs_to :payment_source, polymorphic: true, optional: true
+
+    validates :payment_method, :status, presence: true
+    validates :external_id, uniqueness: { scope: :payment_method_id }, allow_nil: true
+
+    state_machine :status, initial: :pending do
+      state :pending
+      state :processing
+      state :completed
+      state :failed
+      state :canceled
+      state :expired
+
+      event :process do
+        transition pending: :processing
+      end
+
+      event :complete do
+        transition [:pending, :processing] => :completed
+      end
+
+      event :fail do
+        transition [:pending, :processing] => :failed
+      end
+
+      event :cancel do
+        transition [:pending, :processing] => :canceled
+      end
+
+      event :expire do
+        transition [:pending, :processing] => :expired
+      end
+
+      after_transition to: :processing, do: :publish_processing_event
+      after_transition to: :completed, do: :publish_completed_event
+      after_transition to: :failed, do: :publish_failed_event
+      after_transition to: :canceled, do: :publish_canceled_event
+      after_transition to: :expired, do: :publish_expired_event
+    end
+
+    scope :active, -> { where(status: %w[pending processing]) }
+
+    private
+
+    def publish_processing_event
+      publish_event('payment_setup_session.processing')
+    end
+
+    def publish_completed_event
+      publish_event('payment_setup_session.completed')
+    end
+
+    def publish_failed_event
+      publish_event('payment_setup_session.failed')
+    end
+
+    def publish_canceled_event
+      publish_event('payment_setup_session.canceled')
+    end
+
+    def publish_expired_event
+      publish_event('payment_setup_session.expired')
+    end
+  end
+end

data/app/models/spree/payment_source.rb

@@ -1,6 +1,8 @@
 # This model is used to store payment sources for non-credit card payments, eg wallet, account, etc.
 module Spree
   class PaymentSource < Spree.base_class
+    has_prefix_id :ps
+
     include Spree::Metafields
     include Spree::Metadata
     include Spree::PaymentSourceConcern

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
@@ -39,6 +34,17 @@ module Spree
           !order.completed? && (order.user == user || order.token && token == order.token)
         end
 
+        # Line item management
+        can :create, Spree::LineItem do |line_item, token|
+          line_item.order.user == user || line_item.order.token && token == line_item.order.token
+        end
+        can :update, Spree::LineItem do |line_item, token|
+          !line_item.order.completed? && (line_item.order.user == user || line_item.order.token && token == line_item.order.token)
+        end
+        can :destroy, Spree::LineItem do |line_item, token|
+          !line_item.order.completed? && (line_item.order.user == user || line_item.order.token && token == line_item.order.token)
+        end
+
         # User account management - available to all users (including guests for their own record)
         can :create, Spree.user_class
         can [:show, :update, :destroy], Spree.user_class, id: user.id
@@ -49,6 +55,9 @@ module Spree
         # Credit card management
         can [:read, :destroy], Spree::CreditCard, user_id: user.id
 
+        # Gift card management - users can view their own gift cards
+        can :read, Spree::GiftCard, user_id: user.id
+
         # Wishlist management
         can :manage, Spree::Wishlist, user_id: user.id
         can :show, Spree::Wishlist do |wishlist|
@@ -60,6 +69,11 @@ module Spree
 
         # Invitation acceptance
         can :accept, Spree::Invitation, invitee_id: [user.id, nil], invitee_type: user.class.name, status: 'pending'
+
+        # Digital downloads - token-based access
+        can :show, Spree::DigitalLink do |digital_link, token|
+          digital_link.token == token
+        end
       end
     end
   end

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/policy.rb

@@ -1,5 +1,7 @@
 module Spree
   class Policy < Spree.base_class
+    has_prefix_id :pol
+
     extend FriendlyId
     include Spree::TranslatableResource
 

data/app/models/spree/price.rb

@@ -1,5 +1,7 @@
 module Spree
   class Price < Spree.base_class
+    has_prefix_id :price
+
     include Spree::VatPriceCalculation
 
     publishes_lifecycle_events
@@ -38,13 +40,13 @@ module Spree
     scope :discounted, -> { where('compare_at_amount > amount') }
     scope :base_prices, -> { where(price_list_id: nil) }
     scope :for_price_list, ->(price_list) { where(price_list_id: price_list) }
-    scope :for_products, ->(products, currency = nil) do
+    scope :for_products, lambda { |products, currency = nil|
       currency ||= Spree::Store.default.default_currency
 
       with_currency(currency).joins(:variant).where(
         Spree::Variant.table_name => { product_id: products }
       )
-    end
+    }
 
     extend DisplayMoney
     money_methods :amount, :price, :compare_at_amount
@@ -64,6 +66,12 @@ module Spree
       self[:amount] = amount.blank? ? nil : Spree::LocalizedNumber.parse(amount)
     end
 
+    # Returns the amount in cents
+    # @return [Integer]
+    def amount_in_cents
+      display_amount&.amount_in_cents
+    end
+
     def compare_at_money
       Spree::Money.new(compare_at_amount || 0, currency: currency)
     end
@@ -74,6 +82,22 @@ module Spree
       self[:compare_at_amount] = calculated_value
     end
 
+    # Returns the compare at amount for display
+    # @return [Spree::Money, nil]
+    def display_compare_at_amount
+      return nil if compare_at_amount.nil?
+
+      Spree::Money.new(compare_at_amount, currency: currency)
+    end
+
+    # Returns the compare at amount in cents
+    # @return [Integer, nil]
+    def compare_at_amount_in_cents
+      return nil if compare_at_amount.nil?
+
+      display_compare_at_amount.amount_in_cents
+    end
+
     alias_attribute :price, :amount
     alias_method :price=, :amount=
     alias_attribute :compare_at_price, :compare_at_amount

data/app/models/spree/price_list.rb

@@ -1,5 +1,7 @@
 module Spree
   class PriceList < Spree.base_class
+    has_prefix_id :pl
+
     acts_as_paranoid
     acts_as_list scope: :store_id
 

data/app/models/spree/price_rule.rb

@@ -1,5 +1,7 @@
 module Spree
   class PriceRule < Spree.base_class
+    has_prefix_id :prule
+
     belongs_to :price_list, class_name: 'Spree::PriceList', touch: true
 
     validates :type, :price_list,presence: true

data/app/models/spree/price_rules/market_rule.rb

@@ -0,0 +1,19 @@
+module Spree
+  module PriceRules
+    class MarketRule < Spree::PriceRule
+      preference :market_ids, :array, default: []
+
+      def applicable?(context)
+        return false unless context.market
+        return true if preferred_market_ids.empty?
+
+        # Compare as strings to support both integer and UUID primary keys
+        preferred_market_ids.map(&:to_s).include?(context.market.id.to_s)
+      end
+
+      def self.description
+        'Apply pricing based on the market'
+      end
+    end
+  end
+end

data/app/models/spree/product.rb

@@ -20,12 +20,14 @@
 
 module Spree
   class Product < Spree.base_class
+    has_prefix_id :prod # Stripe: prod_
+
     acts_as_paranoid
     acts_as_taggable_on :tags, :labels
     normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
     include Spree::ProductScopes
-    include Spree::MultiStoreResource
+    include Spree::StoreScopedResource
     include Spree::TranslatableResource
     include Spree::MemoizedData
     include Spree::Metafields
@@ -70,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
@@ -117,6 +116,8 @@ module Spree
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
     has_many :variant_images_without_master, -> { order(:position) }, source: :images, through: :variants
 
+    belongs_to :thumbnail, class_name: 'Spree::Image', optional: true
+
     has_many :option_value_variants, class_name: 'Spree::OptionValueVariant', through: :variants
     has_many :option_values, class_name: 'Spree::OptionValue', through: :variants
 
@@ -211,9 +212,6 @@ module Spree
 
     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,
@@ -230,11 +228,12 @@ module Spree
 
     alias options product_option_types
 
-    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status]
+    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]
+                                             multi_search in_stock_items out_of_stock_items with_option_value_ids
+                                             ascend_by_price descend_by_price]
 
     [
       :sku, :barcode, :weight, :height, :width, :depth, :is_master, :dimensions_unit, :weight_unit
@@ -252,6 +251,9 @@ module Spree
     delegate :display_amount, :display_price, :has_default_price?, :track_inventory?,
              :display_compare_at_price, :images, to: :default_variant
 
+    # Rails doesn't provide _id methods for has_one associations by default
+    delegate :id, to: :master, prefix: true, allow_nil: true
+
     alias master_images images
 
     state_machine :status, initial: :draft do
@@ -290,12 +292,12 @@ module Spree
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def purchasable?
-      @purchasable ||= default_variant.purchasable? || variants.in_stock_or_backorderable.any?
+      @purchasable ||= default_variant.purchasable? || variants.any?(&:purchasable?)
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def in_stock?
-      @in_stock ||= default_variant.in_stock? || variants.in_stock.any?
+      @in_stock ||= default_variant.in_stock? || variants.any?(&:in_stock?)
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
@@ -362,9 +364,10 @@ module Spree
     end
 
     # Returns default Image for Product.
+    # Uses cached thumbnail_id which is updated when images are added/removed/reordered.
     # @return [Spree::Image, nil]
     def default_image
-      variant_for_images&.primary_image
+      thumbnail
     end
 
     # Backward compatibility for Spree 5.2 and earlier.
@@ -390,6 +393,13 @@ module Spree
       variant_for_images&.image_count || 0
     end
 
+    # Updates the thumbnail_id to the first image from variant_images.
+    # Called when images are added, removed, or reordered on any variant.
+    def update_thumbnail!
+      first_image = variant_images.order(:position).first
+      update_column(:thumbnail_id, first_image&.id)
+    end
+
     # Finds first variant with images using preloaded data when available.
     # @return [Spree::Variant, nil]
     def find_variant_with_images
@@ -401,7 +411,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
@@ -463,13 +473,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
@@ -497,14 +500,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}%")
@@ -521,48 +516,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
@@ -598,15 +551,13 @@ module Spree
                          nil
                        elsif Spree.use_translations?
                          taxons.joins(:taxonomy).
-                            join_translation_table(Taxonomy).
-                            find_by(Taxonomy.translation_table_alias => { name: Spree.t(:taxonomy_brands_name) })
-                        else
-                          if taxons.loaded?
-                            taxons.find { |taxon| taxon.taxonomy.name == Spree.t(:taxonomy_brands_name) }
-                          else
-                            taxons.joins(:taxonomy).find_by(Taxonomy.table_name => { name: Spree.t(:taxonomy_brands_name) })
-                          end
-                        end
+                           join_translation_table(Taxonomy).
+                           find_by(Taxonomy.translation_table_alias => { name: Spree.t(:taxonomy_brands_name) })
+                       elsif taxons.loaded?
+                         taxons.find { |taxon| taxon.taxonomy.name == Spree.t(:taxonomy_brands_name) }
+                       else
+                         taxons.joins(:taxonomy).find_by(Taxonomy.table_name => { name: Spree.t(:taxonomy_brands_name) })
+                       end
     end
 
     # Returns the brand name for the product
@@ -638,12 +589,10 @@ module Spree
                               join_translation_table(Taxonomy).
                               order(depth: :desc).
                               find_by(Taxonomy.translation_table_alias => { name: Spree.t(:taxonomy_categories_name) })
+                          elsif taxons.loaded?
+                            taxons.find { |taxon| taxon.taxonomy.name == Spree.t(:taxonomy_categories_name) }
                           else
-                            if taxons.loaded?
-                              taxons.find { |taxon| taxon.taxonomy.name == Spree.t(:taxonomy_categories_name) }
-                            else
-                              taxons.joins(:taxonomy).order(depth: :desc).find_by(Taxonomy.table_name => { name: Spree.t(:taxonomy_categories_name) })
-                            end
+                            taxons.joins(:taxonomy).order(depth: :desc).find_by(Taxonomy.table_name => { name: Spree.t(:taxonomy_categories_name) })
                           end
     end
 
@@ -656,9 +605,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?
@@ -690,16 +637,16 @@ module Spree
 
     def to_csv(store = nil)
       store ||= stores.default || stores.first
-      properties_for_csv = if Spree::Config[:product_properties_enabled]
-        Spree::Property.order(:position).flat_map do |property|
-          [
-            property.name,
-            product_properties.find { |pp| pp.property_id == property.id }&.value
-          ]
-        end
-      else
-        []
-      end
+      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,
+                                 product_properties.find { |pp| pp.property_id == property.id }&.value
+                               ]
+                             end
+                           else
+                             []
+                           end
       metafields_for_csv ||= Spree::MetafieldDefinition.for_resource_type('Spree::Product').order(:namespace, :key).map do |mf_def|
         metafields.find { |mf| mf.metafield_definition_id == mf_def.id }&.csv_value
       end
@@ -734,9 +681,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/rules/country.rb

@@ -30,7 +30,7 @@ module Spree
 
         def validate_eligibility_by_country_iso(order)
           country_iso = order.ship_address&.country_iso
-          return true if country_iso == (preferred_country_iso || order.store.default_country_iso)
+          return true if country_iso == (preferred_country_iso || order.store.default_market&.default_country&.iso)
 
           eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
           false

data/app/models/spree/promotion.rb

@@ -1,6 +1,8 @@
 module Spree
   class Promotion < Spree.base_class
-    include Spree::MultiStoreResource
+    has_prefix_id :promo  # Spree-specific: promotion
+
+    include Spree::StoreScopedResource
     include Spree::Metafields
     include Spree::Metadata
     if defined?(Spree::Security::Promotions)
@@ -188,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_action.rb

@@ -2,6 +2,8 @@
 # PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
 module Spree
   class PromotionAction < Spree.base_class
+    has_prefix_id :pact
+
     acts_as_paranoid
 
     belongs_to :promotion, class_name: 'Spree::Promotion', touch: true

data/app/models/spree/promotion_category.rb

@@ -1,5 +1,7 @@
 module Spree
   class PromotionCategory < Spree.base_class
+    has_prefix_id :procat
+
     validates :name, presence: true
     has_many :promotions
   end

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/promotion_rule.rb

@@ -1,6 +1,8 @@
 # Base class for all promotion rules
 module Spree
   class PromotionRule < Spree.base_class
+    has_prefix_id :prorule
+
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, touch: true
 
     delegate :stores, to: :promotion

data/app/models/spree/prototype.rb

@@ -1,9 +1,8 @@
 module Spree
   class Prototype < Spree.base_class
-    include Spree::Metadata
+    has_prefix_id :proto
 
-    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
-    has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
+    include Spree::Metadata
 
     has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
     has_many :option_types, through: :option_type_prototypes, class_name: 'Spree::OptionType'