spree_core 5.0.6 → 5.1.0.beta

data/app/models/spree/credit_card.rb

@@ -2,8 +2,6 @@ module Spree
   class CreditCard < Spree.base_class
     include ActiveMerchant::Billing::CreditCardMethods
     include Spree::Metadata
-    include Spree::PaymentSourceConcern
-
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end
@@ -137,6 +135,30 @@ module Spree
       brand.present? ? brand.upcase : Spree.t(:no_cc_type)
     end
 
+    def actions
+      %w{capture void credit}
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # Indicates whether its possible to void the payment.
+    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.
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
     # ActiveMerchant needs first_name/last_name because we pass it a Spree::CreditCard and it calls those methods on it.
     # Looking at the ActiveMerchant source code we should probably be calling #to_active_merchant before passing
     # the object to ActiveMerchant but this should do for now.

data/app/models/spree/custom_domain.rb

@@ -14,7 +14,7 @@ module Spree
     # Validations
     #
     validates :url, presence: true, uniqueness: true, format: {
-      with: %r{[a-z][a-z0-9-]*[a-z0-9]}i
+      with: %r{\A(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z}i
     }, length: { in: 1..63 }
     validate :url_is_valid
 
@@ -26,9 +26,10 @@ module Spree
     after_validation :ensure_default, on: :create
 
     def url_is_valid
+      return if url.blank?
       parts = url.split('.')
 
-      errors.add(:url, 'use domain or subdomain') if parts.size > 4 || parts.size < 2
+      errors.add(:url, 'use domain or subdomain') if (parts[0] != 'www' && parts.size > 3) || (parts[0] == 'www' && parts.size > 4) || parts.size < 2
     end
 
     def ensure_default

data/app/models/spree/export.rb

@@ -124,7 +124,7 @@ module Spree
     end
 
     def current_ability
-      @current_ability ||= Spree::Dependencies.ability_class.constantize.new(user)
+      @current_ability ||= Spree::Dependencies.ability_class.constantize.new(user, { store: store })
     end
 
     # eg. Spree::Exports::Products => products-store-my-store-code-20241030133348.csv

data/app/models/spree/integration.rb

@@ -0,0 +1,63 @@
+module Spree
+  class Integration < Spree.base_class
+    include Spree::SingleStoreResource
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store', touch: true
+
+    #
+    # Validations
+    #
+    validates :type, presence: true
+    validates :store, presence: true, uniqueness: { scope: :type }
+
+    #
+    # Scopes
+    #
+    scope :active, -> { where(active: true) }
+
+    # This attribute is used to temporarily store connection-related error messages
+    # that can be displayed to users when testing or validating integration connections.
+    # It is not persisted to the database and is reset on each new connection attempt.
+    # @param message [String, nil] The error message to be stored
+    # @return [String, nil] The current error message
+    attr_accessor :connection_error_message
+
+    # Associates the integration to a group.
+    # The name here will be used as Spree.t key to display the group name.
+    # Leave blank to leave the integration ungrouped.
+    def self.integration_group
+      nil
+    end
+
+    def self.icon_path
+      nil
+    end
+
+    def self.integration_name
+      name.demodulize.titleize.strip
+    end
+
+    def self.integration_key
+      name.demodulize.underscore
+    end
+
+    def name
+      self.class.integration_name
+    end
+
+    def key
+      self.class.integration_key
+    end
+
+    # Checks if the integration can establish a connection.
+    # This is a base implementation that always returns true.
+    # Subclasses should override this method to implement their own connection validation logic.
+    # @return [Boolean] true if the integration can connect, false otherwise
+    def can_connect?
+      true
+    end
+  end
+end

data/app/models/spree/invitation.rb

@@ -0,0 +1,153 @@
+module Spree
+  class Invitation < Spree.base_class
+    has_secure_token
+    acts_as_paranoid
+
+    #
+    # Virtual Attributes
+    #
+    attribute :skip_email, :boolean, default: false
+
+    #
+    # Associations
+    #
+    belongs_to :resource, polymorphic: true # eg. Store, Vendor, Account
+    belongs_to :inviter, polymorphic: true # User or AdminUser
+    belongs_to :invitee, polymorphic: true, optional: true # User or AdminUser
+    belongs_to :role, class_name: 'Spree::Role'
+    has_one :role_user, dependent: :destroy, class_name: 'Spree::RoleUser'
+
+    #
+    # Validations
+    #
+    validates :email, email: true, presence: true
+    validates :token, presence: true, uniqueness: true
+    validates :inviter, :resource, :role, presence: true
+    validate :invitee_is_not_inviter, on: :create
+    validate :invitee_already_exists, on: :create
+
+    #
+    # Scopes
+    #
+    scope :pending, -> { where(status: 'pending') }
+    scope :accepted, -> { where(status: 'accepted') }
+    scope :not_expired, -> { where('expires_at > ?', Time.current) }
+
+    #
+    # State Machine
+    #
+    state_machine initial: :pending, attribute: :status do
+      state :accepted do
+        validate :accept_invitation_within_time_limit
+        validates :invitee, presence: true
+      end
+
+      event :accept do
+        transition pending: :accepted
+      end
+      after_transition to: :accepted, do: :after_accept
+    end
+
+    #
+    # Callbacks
+    #
+    after_initialize :set_defaults, if: :new_record?
+    before_validation :set_invitee_from_email, on: :create
+    after_create :send_invitation_email, unless: :skip_email
+
+    # returns the store for the invitation
+    # if the resource is a store, return the resource
+    # if the resource responds to store, return the store
+    # otherwise, return the current store
+    # @return [Spree::Store]
+    def store
+      if resource.is_a?(Spree::Store)
+        resource
+      elsif resource.respond_to?(:store)
+        resource.store
+      else
+        Spree::Store.current
+      end
+    end
+
+    # returns true if the invitation has expired
+    # @return [Boolean]
+    def expired?
+      expires_at < Time.current
+    end
+
+    # Resends the invitation email if the invitation is pending and not expired
+    def resend!
+      return if expired? || deleted? || accepted?
+
+      send_invitation_email
+    end
+
+    private
+
+    # this method can be extended by developers now
+    def after_accept
+      create_role_user
+      set_accepted_at
+      send_acceptance_notification
+    end
+
+    def send_invitation_email
+      Spree::InvitationMailer.invitation_email(self).deliver_later
+    end
+
+    def send_acceptance_notification
+      Spree::InvitationMailer.invitation_accepted(self).deliver_later
+    end
+
+    def set_defaults
+      self.expires_at ||= 2.weeks.from_now
+      self.resource ||= Spree::Store.current
+      self.role ||= Spree::Role.default_admin_role
+    end
+
+    def invitee_is_not_inviter
+      if invitee == inviter
+        errors.add(:invitee, 'cannot be the same as the inviter')
+      end
+    end
+
+    def invitee_already_exists
+      return if resource.blank?
+
+      exists = if invitee.present?
+                resource.users.include?(invitee)
+              else
+                resource.users.exists?(email: email)
+              end
+
+      if exists
+        errors.add(:email, 'already exists')
+      end
+    end
+
+    def set_accepted_at
+      update!(accepted_at: Time.current)
+    end
+
+    def create_role_user
+      return if invitee.blank?
+
+      role_user = resource.add_user(invitee, role)
+      self.role_user = role_user
+      save!
+    end
+
+    def set_invitee_from_email
+      return if invitee.present?
+
+      self.invitee = Spree.admin_user_class.find_by(email: email)
+    end
+
+    def accept_invitation_within_time_limit
+      if Time.current > expires_at
+        errors.add(:base, 'Invitation expired')
+      end
+    end
+  end
+end

data/app/models/spree/invitations/store.rb

@@ -0,0 +1,6 @@
+module Spree
+  module Invitations
+    class Store < Base
+    end
+  end
+end

data/app/models/spree/option_value.rb

@@ -62,9 +62,9 @@ module Spree
     delegate :name, :presentation, to: :option_type, prefix: true, allow_nil: true
 
     def self.to_tom_select_json
-      all.pluck(:name, :presentation).map do |name, presentation|
+      all.pluck(:id, :presentation).map do |id, presentation|
         {
-          id: name,
+          id: id,
           name: presentation
         }
       end

data/app/models/spree/order.rb

@@ -91,6 +91,8 @@ module Spree
     acts_as_taggable_on :tags
     acts_as_taggable_tenant :store_id
 
+    ASSOCIATED_USER_ATTRIBUTES = [:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id]
+
     belongs_to :user, class_name: "::#{Spree.user_class}", optional: true, autosave: true
     belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
     belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
@@ -247,6 +249,13 @@ module Spree
       pre_tax_item_amount + shipments.sum(:pre_tax_amount)
     end
 
+    # Returns the subtotal used for analytics integrations
+    # It's a sum of the item total and the promo total
+    # @return [Float]
+    def analytics_subtotal
+      (item_total + line_items.sum(:promo_total)).to_f
+    end
+
     def shipping_discount
       shipment_adjustments.non_tax.eligible.sum(:amount) * - 1
     end
@@ -355,7 +364,7 @@ module Spree
       self.bill_address ||= user.bill_address
       self.ship_address ||= user.ship_address
 
-      changes = slice(:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id)
+      changes = slice(*ASSOCIATED_USER_ATTRIBUTES)
 
       # immediately persist the changes we just made, but don't use save
       # since we might have an invalid address associated
@@ -364,6 +373,12 @@ module Spree
       end
     end
 
+    def disassociate_user!
+      nullified_attributes = ASSOCIATED_USER_ATTRIBUTES.index_with(nil)
+
+      update!(nullified_attributes)
+    end
+
     def quantity_of(variant, options = {})
       line_item = find_line_item_by_variant(variant, options)
       line_item ? line_item.quantity : 0
@@ -815,10 +830,6 @@ module Spree
       csv_lines
     end
 
-    def all_line_items
-      line_items
-    end
-
     private
 
     def link_by_email

data/app/models/spree/order_merger.rb

@@ -7,7 +7,7 @@ module Spree
       @order = order
     end
 
-    def merge!(other_order, user = nil)
+    def merge!(other_order, user = nil, discard_merged: true)
       other_order.line_items.each do |other_order_line_item|
         next unless other_order_line_item.currency == order.currency
 
@@ -16,12 +16,14 @@ module Spree
       end
 
       set_user(user)
-      clear_addresses(other_order)
+      clear_addresses(other_order) if discard_merged
       persist_merge
 
-      # So that the destroy doesn't take out line items which may have been re-assigned
-      other_order.line_items.reload
-      other_order.destroy
+      if discard_merged
+        # So that the destroy doesn't take out line items which may have been re-assigned
+        other_order.line_items.reload
+        other_order.destroy
+      end
     end
 
     # Compare the line item of the other order with mine.

data/app/models/spree/page_sections/featured_posts.rb

@@ -19,10 +19,6 @@ module Spree
         'news'
       end
 
-      def posts
-        Spree::Post.published.by_newest.limit(preferred_max_posts_to_show)
-      end
-
       private
 
       def make_posts_to_show_valid

data/app/models/spree/payment.rb

@@ -302,8 +302,7 @@ module Spree
       # Payment profile cannot be created without source
       return unless source
       # Imported payments shouldn't create a payment profile.
-      # Imported is only available on Spree::CreditCard, non-credit card payments should not have this attribute.
-      return if source.respond_to?(:imported) && source.imported
+      return if source.imported
 
       payment_method.create_profile(self)
     rescue ActiveMerchant::ConnectionError => e

data/app/models/spree/payment_source.rb

@@ -1,31 +1,10 @@
-# This model is used to store payment sources for non-credit card payments, eg wallet, account, etc.
 module Spree
   class PaymentSource < Spree.base_class
     include Spree::Metadata
-    include Spree::PaymentSourceConcern
 
-    #
-    # Associations
-    #
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
     belongs_to :user, class_name: Spree.user_class.to_s, optional: true
 
-    #
-    # Validations
-    #
     validates_uniqueness_of :gateway_payment_profile_id, scope: :type
-
-    #
-    # Delegations
-    #
-    delegate :profile_id, to: :gateway_customer, prefix: true, allow_nil: true
-
-    # Returns the gateway customer for the user.
-    # @return [Spree::GatewayCustomer]
-    def gateway_customer
-      return if user.blank?
-
-      payment_method.gateway_customers.find_by(user: user)
-    end
   end
 end

data/app/models/spree/post.rb

@@ -54,7 +54,6 @@ module Spree
     # Scopes
     #
     scope :published, -> { where(published_at: [..Time.current]) }
-    scope :by_newest, -> { order(created_at: :desc) }
 
     delegate :name, to: :author, prefix: true, allow_nil: true
     delegate :title, to: :post_category, prefix: true, allow_nil: true

data/app/models/spree/product.rb

@@ -20,17 +20,14 @@
 
 module Spree
   class Product < Spree.base_class
-    acts_as_paranoid
-    acts_as_taggable_on :tags, :labels
-    auto_strip_attributes :name
-
+    extend FriendlyId
     include Spree::ProductScopes
     include Spree::MultiStoreResource
     include Spree::TranslatableResource
+    include Spree::TranslatableResourceSlug
     include Spree::MemoizedData
     include Spree::Metadata
     include Spree::Product::Webhooks
-    include Spree::Product::Slugs
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
     end
@@ -56,8 +53,33 @@ module Spree
         pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' },
                                          using: { tsearch: { prefix: true, any_word: true } }
       end
+
+      before_save :set_slug
+      acts_as_paranoid
+      # deleted translation values also need to be accessible for index views listing deleted resources
+      default_scope { unscope(where: :deleted_at) }
+      def set_slug
+        self.slug = generate_slug
+      end
+
+      private
+
+      def generate_slug
+        if name.blank? && slug.blank?
+          translated_model.name.to_url
+        elsif slug.blank?
+          name.to_url
+        else
+          slug.to_url
+        end
+      end
     end
 
+    friendly_id :slug_candidates, use: [:history, :scoped, :mobility], scope: spree_base_uniqueness_scope
+    acts_as_paranoid
+    auto_strip_attributes :name
+    acts_as_taggable_on :tags, :labels
+
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
     before_destroy :ensure_not_in_complete_orders
@@ -123,12 +145,17 @@ module Spree
     after_initialize :ensure_master
     after_initialize :assign_default_tax_category
 
+    before_validation :downcase_slug
+    before_validation :normalize_slug, on: :update
     before_validation :validate_master
     before_validation :ensure_default_shipping_category
 
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
+    after_destroy :punch_slug
+    after_restore :update_slug_history
+
     after_save :save_master
     after_save :run_touch_callbacks, if: :anything_changed?
     after_save :reset_nested_changes
@@ -146,6 +173,7 @@ module Spree
       validates :price, if: :requires_price?
     end
 
+    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true, scope: spree_base_uniqueness_scope }
     validate :discontinue_on_must_be_later_than_make_active_at, if: -> { make_active_at && discontinue_on }
 
     scope :for_store, ->(store) { joins(:store_products).where(StoreProduct.table_name => { store_id: store.id }) }
@@ -484,6 +512,17 @@ module Spree
       where conditions.inject(:or)
     end
 
+    def self.slug_available?(slug, id)
+      !where(slug: slug).where.not(id: id).exists?
+    end
+
+    def ensure_slug_is_unique(candidate_slug)
+      return slug if candidate_slug.blank? || slug.blank?
+      return candidate_slug if self.class.slug_available?(candidate_slug, id)
+
+      normalize_friendly_id([candidate_slug, uuid_for_friendly_id])
+    end
+
     # Suitable for displaying only variants that has at least one option value.
     # There may be scenarios where an option type is removed and along with it
     # all option values. At that point all variants associated with only those
@@ -699,6 +738,25 @@ module Spree
       self.tax_category = Spree::TaxCategory.default if new_record?
     end
 
+    def normalize_slug
+      self.slug = normalize_friendly_id(slug)
+    end
+
+    def punch_slug
+      # punch slug with date prefix to allow reuse of original
+      return if frozen?
+
+      update_column(:slug, "#{Time.current.to_i}_#{slug}"[0..254])
+
+      translations.with_deleted.each do |t|
+        t.update_column :slug, "#{Time.current.to_i}_#{t.slug}"[0..254]
+      end
+    end
+
+    def update_slug_history
+      save!
+    end
+
     def anything_changed?
       saved_changes? || @nested_changes
     end
@@ -754,6 +812,14 @@ module Spree
       end
     end
 
+    # Try building a slug based on the following fields in increasing order of specificity.
+    def slug_candidates
+      [
+        :name,
+        [:name, :sku]
+      ]
+    end
+
     def run_touch_callbacks
       run_callbacks(:touch)
     end
@@ -801,6 +867,10 @@ module Spree
       previously_new_record? || tag_list_previously_changed? || available_on_previously_changed?
     end
 
+    def downcase_slug
+      slug&.downcase!
+    end
+
     def after_activate
       # Implement your logic here
     end

data/app/models/spree/product_property.rb

@@ -33,7 +33,7 @@ module Spree
     scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
     scope :for_products, ->(products) { joins(:product).merge(products) }
     scope :sort_by_property_position, -> {
-      joins(:property).order("spree_properties.position ASC")
+      unscope(:order).joins(:property).order("spree_properties.position ASC")
     }
 
     self.whitelisted_ransackable_attributes = ['value', 'filter_param']

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

@@ -27,39 +27,39 @@ module Spree
             upper_limit_condition = true
           end
 
-          eligibility_errors.add(:base, ineligible_message_max(order)) unless upper_limit_condition
-          eligibility_errors.add(:base, ineligible_message_min(order)) unless lower_limit_condition
+          eligibility_errors.add(:base, ineligible_message_max) unless upper_limit_condition
+          eligibility_errors.add(:base, ineligible_message_min) unless lower_limit_condition
 
           eligibility_errors.empty?
         end
 
         private
 
-        def formatted_amount_min(order)
-          Spree::Money.new(preferred_amount_min, currency: order.currency).to_s
+        def formatted_amount_min
+          Spree::Money.new(preferred_amount_min).to_s
         end
 
-        def formatted_amount_max(order)
+        def formatted_amount_max
           if preferred_amount_max.present?
-            Spree::Money.new(preferred_amount_max, currency: order.currency).to_s
+            Spree::Money.new(preferred_amount_max).to_s
           else
             Spree.t('no_maximum')
           end
         end
 
-        def ineligible_message_max(order)
+        def ineligible_message_max
           if preferred_operator_max == 'lt'
-            eligibility_error_message(:item_total_more_than_or_equal, amount: formatted_amount_max(order))
+            eligibility_error_message(:item_total_more_than_or_equal, amount: formatted_amount_max)
           else
-            eligibility_error_message(:item_total_more_than, amount: formatted_amount_max(order))
+            eligibility_error_message(:item_total_more_than, amount: formatted_amount_max)
           end
         end
 
-        def ineligible_message_min(order)
+        def ineligible_message_min
           if preferred_operator_min == 'gte'
-            eligibility_error_message(:item_total_less_than, amount: formatted_amount_min(order))
+            eligibility_error_message(:item_total_less_than, amount: formatted_amount_min)
           else
-            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount_min(order))
+            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount_min)
           end
         end
       end

data/app/models/spree/property.rb

@@ -39,8 +39,10 @@ module Spree
     KIND_OPTIONS = { short_text: 0, long_text: 1, number: 2, rich_text: 3 }.freeze
     enum :kind, KIND_OPTIONS
 
+    DEPENDENCY_UPDATE_FIELDS = [:presentation, :name, :kind, :filterable, :display_on, :position].freeze
+
     after_touch :touch_all_products
-    after_update :touch_all_products, if: -> { saved_changes.key?(:presentation) }
+    after_update :touch_all_products, if: -> { DEPENDENCY_UPDATE_FIELDS.any? { |field| saved_changes.key?(field) } }
     after_save :ensure_product_properties_have_filter_params
 
     self.whitelisted_ransackable_attributes = ['presentation', 'filterable']