spree_core 5.1.7 → 5.2.0.rc1

data/app/presenters/spree/csv/product_variant_presenter.rb

@@ -47,7 +47,7 @@ module Spree
         'category3',
       ].freeze
 
-      def initialize(product, variant, index = 0, properties = [], taxons = [], store = nil)
+      def initialize(product, variant, index = 0, properties = [], taxons = [], store = nil, metafields = [])
         @product = product
         @variant = variant
         @index = index
@@ -55,9 +55,10 @@ module Spree
         @taxons = taxons
         @store = store || product.stores.first
         @currency = @store.default_currency
+        @metafields = metafields
       end
 
-      attr_accessor :product, :variant, :index, :properties, :taxons, :store, :currency
+      attr_accessor :product, :variant, :index, :properties, :taxons, :store, :currency, :metafields
 
       ##
       # Generates an array representing a CSV row of product variant data.
@@ -71,11 +72,13 @@ module Spree
       #
       # @return [Array] An array containing the combined product and variant CSV data.
       def call
+        total_on_hand = variant.total_on_hand
+
         csv = [
           product.id,
           variant.sku,
           index.zero? ? product.name : nil,
-          index.zero? ? product.slug : nil,
+          product.slug,
           index.zero? ? product.status : nil,
           index.zero? ? product.try(:vendor_name) : nil,
           index.zero? ? product.try(:brand_name) : nil,
@@ -86,7 +89,7 @@ module Spree
           index.zero? ? product.tag_list.to_s : nil,
           index.zero? ? product.label_list.to_s : nil,
           variant.amount_in(currency).to_f,
-          variant.compare_at_price&.to_f,
+          variant.compare_at_amount_in(currency).to_f,
           currency,
           variant.width,
           variant.height,
@@ -97,7 +100,7 @@ module Spree
           variant.available_on&.strftime('%Y-%m-%d %H:%M:%S'),
           (variant.discontinue_on || product.discontinue_on)&.strftime('%Y-%m-%d %H:%M:%S'),
           variant.track_inventory?,
-          variant.total_on_hand == BigDecimal::INFINITY ? '∞' : variant.total_on_hand,
+          total_on_hand == BigDecimal::INFINITY ? '∞' : total_on_hand,
           variant.backorderable?,
           variant.tax_category&.name,
           variant.digital?,
@@ -115,6 +118,7 @@ module Spree
         if index.zero?
           csv += taxons
           csv += properties
+          csv += metafields
         end
 
         csv

data/app/services/spree/addresses/update.rb

@@ -12,12 +12,19 @@ module Spree
         default_shipping = opts.fetch(:default_shipping, false)
         address_changes_except = opts.fetch(:address_changes_except, [])
         create_new_address_on_update = opts.fetch(:create_new_address_on_update, false)
+        Spree::Deprecation.warn('Spree::Addresses::Update create_new_address_on_update parameter is deprecated and will be removed in Spree 6.') if create_new_address_on_update
 
         prepare_address_params!(address, address_params)
         address.assign_attributes(address_params)
 
-        address_changed = address.changes.except(*address_changes_except).any?
+        address_changes = address.changes.except(*address_changes_except)
 
+        # Ignore changes that are only different in case as encrypted fields are processed by rails as downcased
+        address_changes.reject! do |attr, (old_val, new_val)|
+          old_val.to_s.casecmp?(new_val.to_s)
+        end
+
+        address_changed = address_changes.any?
         if !address_changed && defaults_changed?(address, default_billing, default_shipping)
           assign_to_user_as_default(
             user: address.user,

data/app/services/spree/cart/recalculate.rb

@@ -4,11 +4,13 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(order:, line_item:, line_item_created: false, options: {})
-        order.remove_gift_card if order.gift_card.present?
-        order_updater = ::Spree::OrderUpdater.new(order)
+        order_updater = order.updater
 
-        order.payments.store_credits.checkout.destroy_all
-        order_updater.update
+        order.remove_gift_card if order.gift_card.present?
+        order.payments.store_credits.checkout.destroy_all if order.payments.store_credits.checkout.any?
+        order_updater.update_item_count
+        order_updater.update_totals
+        order_updater.persist_totals
 
         shipment = options[:shipment]
         if shipment.present?

data/app/services/spree/cart/remove_line_item.rb

@@ -6,12 +6,11 @@ module Spree
       def call(order:, line_item:, options: nil)
         options ||= {}
         ActiveRecord::Base.transaction do
-          line_item.destroy!
+          order.line_items.destroy(line_item)
           Spree::Dependencies.cart_recalculate_service.constantize.new.call(order: order,
                                                                             line_item: line_item,
                                                                             options: options)
         end
-        order.reload
         success(line_item)
       end
     end

data/app/services/spree/imports/row_processors/base.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Imports
+    module RowProcessors
+      class Base
+        def initialize(row)
+          @row = row
+          @import = row.import
+          @attributes = row.to_schema_hash
+        end
+
+        attr_reader :row, :import, :attributes
+
+        def process!
+          raise NotImplementedError, 'Subclasses must implement the process! method'
+        end
+      end
+    end
+  end
+end

data/app/services/spree/imports/row_processors/product_variant.rb

@@ -0,0 +1,228 @@
+module Spree
+  module Imports
+    module RowProcessors
+      class ProductVariant < Base
+        OPTION_TYPES_COUNT = 3
+
+        def initialize(row)
+          super
+          @store = row.store
+          @product = ensure_product_exists
+        end
+
+        attr_reader :product, :store
+
+        def process!
+          variant_scope = options.empty? ? product.variants_including_master : product.variants
+
+          variant = if attributes['sku'].present?
+                      variant_scope.where(
+                        Spree::Variant.arel_table[:sku].lower.eq(attributes['sku'].strip.downcase)
+                      ).first || product.variants.new
+                    elsif options.empty?
+                      product.master
+                    else
+                      product.variants.new
+                    end
+
+          variant.sku = attributes['sku'] if attributes['sku'].present?
+          variant.cost_price = attributes['cost_price'] if attributes['cost_price'].present?
+          variant.weight = attributes['weight'] if attributes['weight'].present?
+          variant.height = attributes['height'] if attributes['height'].present?
+          variant.width = attributes['width'] if attributes['width'].present?
+          variant.depth = attributes['depth'] if attributes['depth'].present?
+          variant.track_inventory = attributes['track_inventory'] if attributes['track_inventory'].present?
+          variant.option_value_variants = prepare_option_value_variants
+          variant.save!
+
+          if attributes['price'].present?
+            currency = (attributes['currency'].presence || store.default_currency).to_s.strip.upcase
+            variant.set_price(currency, attributes['price'], attributes['compare_at_price'])
+          end
+
+          if attributes['inventory_count'].present?
+            variant.set_stock(attributes['inventory_count'].to_i, attributes['inventory_backorderable']&.to_b, store.default_stock_location)
+          end
+
+          handle_images(variant)
+
+          variant
+        end
+
+        private
+
+        def ensure_product_exists
+          product = Spree::Product.new
+          if attributes['slug'].present?
+            existing_product = product_scope.find_by(slug: attributes['slug'].strip.downcase)
+            product = existing_product if existing_product.present?
+          end
+
+          product = assign_attributes_to_product(product)
+          product.save!
+          handle_metafields(product)
+          product
+        end
+
+        def product_scope
+          Spree::Product.accessible_by(import.current_ability, :manage)
+        end
+
+        def assign_attributes_to_product(product)
+          # setting SKU for master variant so it will be picked up in process! and won't try to create a non-master variant
+          if product.new_record?
+            product.slug = attributes['slug']
+            product.sku = attributes['sku'] if attributes['sku'].present? && options.empty?
+          end
+
+          product.stores << store if product.stores.exclude?(store)
+          product.name = attributes['name'] if attributes['name'].present?
+          product.description = attributes['description'] if attributes['description'].present?
+          product.meta_title = attributes['meta_title'] if attributes['meta_title'].present?
+          product.meta_description = attributes['meta_description'] if attributes['meta_description'].present?
+          product.meta_keywords = attributes['meta_keywords'] if attributes['meta_keywords'].present?
+          product.status = to_spree_status(attributes['status']) if attributes['status'].present?
+          product.tag_list = attributes['tags'] if attributes['tags'].present?
+
+          product.taxons = prepare_taxons if options.empty?
+          product
+        end
+
+        def prepare_taxons
+          taxon_pretty_names = [
+            attributes['category1'],
+            attributes['category2'],
+            attributes['category3']
+          ].compact_blank.map(&:strip).uniq
+
+          return [] if taxon_pretty_names.empty?
+
+          taxons = taxon_pretty_names.map { |taxon_pretty_name| handle_taxon_line(taxon_pretty_name) }
+          taxons.compact
+        end
+
+        def handle_taxon_line(taxon_pretty_name)
+          taxon_names = taxon_pretty_name.strip.split('->').map(&:strip).map(&:presence).compact
+          return if taxon_names.empty?
+
+          taxonomy_name = taxon_names.shift
+          taxonomy = store.taxonomies.with_matching_name(taxonomy_name).first || store.taxonomies.create!(name: taxonomy_name)
+
+          last_taxon = taxonomy.root
+
+          taxon_names.each do |taxon_name|
+            last_taxon = taxonomy.taxons.with_matching_name(taxon_name).where(parent: last_taxon).first || taxonomy.taxons.create!(name: taxon_name, parent: last_taxon)
+          end
+
+          last_taxon
+        end
+
+        def prepare_option_value_variants
+          return [] if options.empty?
+
+          options.map do |option|
+            option_type = Spree::OptionType.search_by_name(option[:option_name]).first || Spree::OptionType.create!(presentation: option[:option_name])
+            option_value = option_type.option_values.search_by_name(option[:option_value]).first || option_type.option_values.create!(presentation: option[:option_value])
+
+            # ensure product option types include new option type
+            Spree::ProductOptionType.find_or_create_by!(product: product, option_type: option_type)
+
+            Spree::OptionValueVariant.new(option_value: option_value)
+          end
+        end
+
+        def handle_images(variant)
+          image_urls = [
+            attributes['image1_src'],
+            attributes['image2_src'],
+            attributes['image3_src'],
+          ].compact.map(&:strip).compact_blank.uniq
+
+          return if image_urls.empty?
+
+          image_urls.each do |image_url|
+            Spree::Images::SaveFromUrlJob.perform_later(variant.id, 'Spree::Variant', image_url)
+          end
+        end
+
+        def options
+          @options ||= begin
+            options = []
+
+            OPTION_TYPES_COUNT.times.map do |index|
+              next if attributes["option#{index + 1}_name"].blank?
+              next if attributes["option#{index + 1}_value"].blank?
+
+              options << {
+                index: index + 1,
+                option_name: attributes["option#{index + 1}_name"],
+                option_value: attributes["option#{index + 1}_value"]
+              }
+            end
+
+            options
+          end
+        end
+
+        def handle_metafields(product)
+          return unless product.class.included_modules.include?(Spree::Metafields)
+
+          metafield_attributes = attributes.select { |key, _value| key.to_s.start_with?('metafield.') }
+          return if metafield_attributes.empty?
+
+          # Build nested attributes for metafields
+          nested_attrs = []
+
+          metafield_attributes.each do |attribute_key, value|
+            # Extract namespace.key from "metafield.namespace.key"
+            full_key = attribute_key.to_s.sub(/^metafield\./, '')
+            namespace, key = product.extract_namespace_and_key(full_key)
+
+            # Find or initialize metafield definition
+            metafield_definition = Spree::MetafieldDefinition.find_by(
+              namespace: namespace,
+              key: key,
+              resource_type: product.class.name
+            )
+
+            next unless metafield_definition
+
+            # Find existing metafield if product is persisted
+            existing_metafield = product.persisted? ? product.metafields.find_by(metafield_definition: metafield_definition) : nil
+
+            # Skip blank values for new metafields
+            next if value.blank? && existing_metafield.nil?
+
+            # For existing metafields with blank values, we'll mark them for destruction
+            # For new metafields, we skip them (handled above)
+            # For existing or new metafields with values, we create/update them
+            metafield_attrs = {
+              metafield_definition_id: metafield_definition.id,
+              value: value.to_s.strip,
+              type: metafield_definition.metafield_type
+            }
+
+            metafield_attrs[:id] = existing_metafield.id if existing_metafield
+
+            nested_attrs << metafield_attrs
+          end
+
+          product.update(metafields_attributes: nested_attrs) unless nested_attrs.empty?
+        end
+
+        def to_spree_status(status)
+          case status.strip.downcase
+          when 'active'
+            'active'
+          when 'draft'
+            'draft'
+          when 'archived'
+            'archived'
+          else
+            'draft'
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree/line_items/destroy.rb

@@ -8,7 +8,7 @@ module Spree
         order = line_item.order
 
         ActiveRecord::Base.transaction do
-          line_item.destroy!
+          order.line_items.destroy(line_item)
           recalculate_service.call(order: order, line_item: line_item, options: options)
         end
         success(line_item)

data/app/services/spree/newsletter/subscribe.rb

@@ -0,0 +1,43 @@
+module Spree
+  module Newsletter
+    class Subscribe
+      def initialize(email:, current_user: nil)
+        @email = email
+        @current_user = current_user
+      end
+
+      def call
+        return existed_subscription if existed_subscription.present?
+
+        ActiveRecord::Base.transaction do
+          upsert_subscriber
+          return subscriber if subscriber.errors.any?
+
+          if subscriber.email == current_user&.email
+            # no need to verified since user email is already verified
+            Spree::Newsletter::Verify.new(subscriber: subscriber).call
+          end
+        end
+
+        # deliver confirmation email after the transaction is completed
+        subscriber.deliver_newsletter_email_verification unless subscriber.verified?
+        subscriber
+      end
+
+      private
+
+      attr_reader :email, :current_user
+
+      def upsert_subscriber
+        @upsert_subscriber ||= Spree::NewsletterSubscriber.find_or_create_by(email: email) do |new_record|
+          new_record.user = Spree.user_class.find_by(email: new_record.email) || current_user
+        end
+      end
+      alias_method :subscriber, :upsert_subscriber
+
+      def existed_subscription
+        @existed_subscription ||= Spree::NewsletterSubscriber.verified.find_by(email: email)
+      end
+    end
+  end
+end

data/app/services/spree/newsletter/verify.rb

@@ -0,0 +1,30 @@
+module Spree
+  module Newsletter
+    class Verify
+      def initialize(subscriber:)
+        @subscriber = subscriber
+      end
+
+      def call
+        verify_subscriber
+        set_user_email_marketing_to_true
+
+        subscriber
+      end
+
+      private
+
+      attr_reader :subscriber
+
+      def verify_subscriber
+        subscriber.update!(verified_at: Time.current, verification_token: nil)
+      end
+
+      def set_user_email_marketing_to_true
+        return if subscriber.user.blank?
+
+        subscriber.user.update!(accepts_email_marketing: true)
+      end
+    end
+  end
+end

data/app/services/spree/orders/create_user_account.rb

@@ -7,7 +7,11 @@ module Spree
 
       def call(order:, accepts_email_marketing: false)
         existing_user = Spree.user_class.find_by(email: order.email)
-        return existing_user if existing_user.present?
+        if existing_user.present?
+          order.update_columns(user_id: existing_user.id, updated_at: Time.current)
+          order.user = existing_user
+          return success(existing_user)
+        end
 
         user = create_new_user(order, accepts_email_marketing)
         return failure(:user_creation_failed) unless user.persisted?

data/app/services/spree/products/prepare_nested_attributes.rb

@@ -1,5 +1,21 @@
 module Spree
   module Products
+    # Prepares nested attributes for product updates, handling multi-store scenarios
+    # and permissions.
+    #
+    # This service ensures that when editing a product in one store, taxon associations
+    # from other stores are preserved. This prevents accidental data loss when a store
+    # admin updates product categories in their store without affecting other stores.
+    #
+    # @example
+    #   service = Spree::Products::PrepareNestedAttributes.new(
+    #     product,
+    #     current_store,
+    #     params,
+    #     current_ability
+    #   )
+    #   prepared_params = service.call
+    #
     class PrepareNestedAttributes
       def initialize(product, store, params, ability)
         @product = product
@@ -60,6 +76,12 @@ module Spree
         # ensure there is at least one store
         params[:store_ids] = [store.id] if params[:store_ids].blank?
 
+        # Preserve taxon associations from other stores
+        # Only merge taxon_ids from other stores if taxon_ids are being updated
+        if params.key?(:taxon_ids)
+          params[:taxon_ids] = merge_taxons_from_other_stores(params[:taxon_ids])
+        end
+
         # Add empty list for option_type_ids and mark variants as removed if there are no variants and options
         if params[:variants_attributes].blank? && variants_to_remove.any? && !params.key?(:option_type_ids)
           params[:option_type_ids] = []
@@ -133,6 +155,28 @@ module Spree
         attributes
       end
 
+      # Merges taxon IDs from other stores with submitted taxon IDs from current store.
+      #
+      # This prevents the loss of taxon associations from other stores when a product
+      # is edited in one store. Each store's taxonomy is independent, so editing
+      # categories in Store A should not affect categories in Store B.
+      #
+      # @param submitted_taxon_ids [Array<String>] Taxon IDs from the current store
+      # @return [Array<String>] Combined unique taxon IDs
+      def merge_taxons_from_other_stores(submitted_taxon_ids)
+        return submitted_taxon_ids if product.new_record?
+
+        # Get taxon IDs from other stores that should be preserved
+        other_stores_taxon_ids = product.taxons
+                                        .joins(:taxonomy)
+                                        .where.not(spree_taxonomies: { store_id: store.id })
+                                        .pluck(:id)
+                                        .map(&:to_s)
+
+        # Merge with submitted taxon IDs from current store and remove duplicates
+        (submitted_taxon_ids + other_stores_taxon_ids).uniq
+      end
+
       def update_option_value_variants(option_value_params, existing_variant)
         return {} unless option_value_params.present?
         return {} unless can_manage_option_types?

data/app/sorters/spree/posts/sort.rb

@@ -0,0 +1,40 @@
+module Spree
+  module Posts
+    class Sort < ::Spree::BaseSorter
+      def initialize(scope, params = {}, allowed_sort_attributes = [])
+        super(scope, params, allowed_sort_attributes)
+      end
+
+      def call
+        posts = by_param_attributes(scope)
+        posts = select_translatable_fields(posts) if Spree.use_translations?
+
+        posts.distinct
+      end
+
+      private
+
+      attr_reader :sort, :scope, :allowed_sort_attributes
+
+      # Add translatable fields to SELECT statement to avoid InvalidColumnReference error (workaround for Mobility issue #596)
+      def select_translatable_fields(scope)
+        translatable_fields = translatable_sortable_fields
+        return scope if translatable_fields.empty?
+
+        scope.i18n.select("#{Post.table_name}.*").select(*translatable_fields)
+      end
+
+      def translatable_sortable_fields
+        fields = []
+        Post.translatable_fields.each do |field|
+          fields << field if sort_by?(field.to_s)
+        end
+        fields
+      end
+
+      def sort_by?(field)
+        sort.detect { |s| s[0] == field }
+      end
+    end
+  end
+end

data/app/{services → validators}/spree/addresses/phone_validator.rb

@@ -8,7 +8,7 @@ module Spree
   module Addresses
     class PhoneValidator < ActiveModel::Validator
       def validate(address)
-        return if !Spree::Config[:address_requires_phone] || address.phone.blank? || address.country.blank? || address.country_iso.blank?
+        return if !address.require_phone? || address.phone.blank? || address.country.blank? || address.country_iso.blank?
 
         phone = Phonelib.parse(address.phone)
         unless phone.valid_for_country?(address.country_iso)

data/app/views/spree/shared/_payment.html.erb

@@ -13,14 +13,16 @@
     </div>
   <% elsif source.is_a?(Spree::StoreCredit) %>
     <% if source.originator_type == 'Spree::GiftCard' %>
-      <div class="d-flex align-items-center">
-        <%= icon('gift', height: 30, class: 'mr-3 text-muted opacity-50') %>
-        <div>
-          <p class="mb-1"><%= Spree.t(:gift_card) %>: <strong><%= source.originator.code.upcase %></strong></p>
-          <%= @order.display_gift_card_total %>
-        </div>
+      <% if respond_to?(:heroicon) %>
+        <%= heroicon('gift', options: { style: 'margin-right: 0 !important;' }) %>
+      <% else %>
+        <%= icon('gift', height: 30) %>
+      <% end %>
+      <div>
+        <p class="mb-1"><%= Spree.t(:gift_card) %>: <strong><%= source.originator.code.upcase %></strong></p>
+        <%= @order.display_gift_card_total %>
       </div>
-    <% elsif payment_method_icon_tag(payment.payment_method.payment_icon_name).present? %>
+    <% elsif payment.payment_method.present? && payment_method_icon_tag(payment.payment_method.payment_icon_name).present? %>
       <div class="d-flex flex align-items-center items-center">
         <div><%= payment_method_icon_tag(payment.payment_method.payment_icon_name) %></div>
         <div class="ml-3"><%= Spree.t(:store_credit_name) %></div>
@@ -31,7 +33,7 @@
       <%= payment_method_icon_tag source.class.to_s.demodulize.downcase, height: 30 %>
     </div>
     <div>
-      <% if payment.payment_method.respond_to?(:source_partial_name) %>
+      <% if payment.payment_method.present? && payment.payment_method.respond_to?(:source_partial_name) %>
         <%= render partial: "spree/payment_sources/#{payment.payment_method.source_partial_name}", locals: { payment: payment, source: source } %>
       <% elsif source.respond_to?(:name) %>
         <%= source.name %>
@@ -39,7 +41,7 @@
         <%= source.class.to_s.demodulize.downcase %>
       <% end %>
     </div>
-  <% else %>
+  <% elsif payment.payment_method.present? %>
     <div class="flex-shrink-0">
       <%= payment_method_icon_tag payment.payment_method.payment_icon_name %>
     </div>