spree_core 4.10.1 → 5.0.0.rc1

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

@@ -0,0 +1,130 @@
+module Spree
+  module CSV
+    class ProductVariantPresenter
+      CSV_HEADERS = [
+        'product_id',
+        'sku',
+        'name',
+        'slug',
+        'status',
+        'vendor_name',
+        'brand_name',
+        'description',
+        'meta_title',
+        'meta_description',
+        'meta_keywords',
+        'tags',
+        'labels',
+        'price',
+        'compare_at_price',
+        'currency',
+        'width',
+        'height',
+        'depth',
+        'dimensions_unit',
+        'weight',
+        'weight_unit',
+        'available_on',
+        'discontinue_on',
+        'track_inventory',
+        'inventory_count',
+        'inventory_backorderable',
+        'tax_category',
+        'digital',
+        'image1_src',
+        'image2_src',
+        'image3_src',
+        'option1_name',
+        'option1_value',
+        'option2_name',
+        'option2_value',
+        'option3_name',
+        'option3_value',
+        'category1',
+        'category2',
+        'category3',
+      ].freeze
+
+      def initialize(product, variant, index = 0, properties = [], taxons = [], store = nil)
+        @product = product
+        @variant = variant
+        @index = index
+        @properties = properties
+        @taxons = taxons
+        @store = store || product.stores.first
+        @currency = @store.default_currency
+      end
+
+      attr_accessor :product, :variant, :index, :properties, :taxons, :store, :currency
+
+      ##
+      # Generates an array representing a CSV row of product variant data.
+      #
+      # For the primary variant row (when the index is zero), product-level details such as name,
+      # slug, status, vendor and brand names, description, meta tags, and tag/label lists are included.
+      # In all cases, variant-specific attributes (e.g., id, SKU, pricing, dimensions, weight,
+      # availability dates, inventory count, digital flag, tax category, image URLs via original_url,
+      # and the first three option types and corresponding option values) are appended.
+      # Additionally, when the index is zero, associated taxons and properties are added.
+      #
+      # @return [Array] An array containing the combined product and variant CSV data.
+      def call
+        csv = [
+          product.id,
+          variant.sku,
+          index.zero? ? product.name : nil,
+          index.zero? ? product.slug : nil,
+          index.zero? ? product.status : nil,
+          index.zero? ? product.try(:vendor_name) : nil,
+          index.zero? ? product.try(:brand_name) : nil,
+          index.zero? ? product.description&.html_safe : nil,
+          index.zero? ? product.meta_title : nil,
+          index.zero? ? product.meta_description : nil,
+          index.zero? ? product.meta_keywords : nil,
+          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,
+          currency,
+          variant.width,
+          variant.height,
+          variant.depth,
+          variant.dimensions_unit,
+          variant.weight,
+          variant.weight_unit,
+          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,
+          variant.backorderable?,
+          variant.tax_category&.name,
+          variant.digital?,
+          variant.images[0]&.original_url,
+          variant.images[1]&.original_url,
+          variant.images[2]&.original_url,
+          index.positive? ? option_type(0)&.presentation : nil,
+          index.positive? ? option_value(option_type(0)) : nil,
+          index.positive? ? option_type(1)&.presentation : nil,
+          index.positive? ? option_value(option_type(1)) : nil,
+          index.positive? ? option_type(2)&.presentation : nil,
+          index.positive? ? option_value(option_type(2)) : nil
+        ]
+
+        if index.zero?
+          csv += taxons
+          csv += properties
+        end
+
+        csv
+      end
+
+      def option_type(index)
+        product.option_types[index]
+      end
+
+      def option_value(option_type)
+        variant.option_values.find { |ov| ov.option_type == option_type }&.presentation
+      end
+    end
+  end
+end

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

@@ -6,19 +6,44 @@ module Spree
 
       attr_accessor :country
 
-      def call(address_params: {}, user: nil)
+      def call(address_params: {}, user: nil, **opts)
+        order = opts[:order]
+        default_billing = opts.fetch(:default_billing, false)
+        default_shipping = opts.fetch(:default_shipping, false)
+
         address_params = fill_country_and_state_ids(address_params)
 
         address = Spree::Address.new(address_params)
         address.user = user if user.present?
 
-        if address.save
-          assign_to_user_as_default(user: user, address_id: address.id) if user.present?
-          success(address)
-        else
-          failure(address)
+        ApplicationRecord.transaction do
+          if address.save
+            if user.present?
+              if user.addresses.pluck(:id) == [address.id]
+                user.update(bill_address_id: address.id, ship_address_id: address.id)
+              else
+                assign_to_user_as_default(
+                  user: user,
+                  address_id: address.id,
+                  default_billing: default_billing,
+                  default_shipping: default_shipping
+                )
+              end
+            end
+
+            assign_to_order(order: order, address_id: address.id) if order.present?
+            success(address)
+          else
+            failure(address)
+          end
         end
       end
+
+      private
+
+      def assign_to_order(order:, address_id:)
+        order.update(ship_address_id: address_id, state: 'address')
+      end
     end
   end
 end

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

@@ -31,10 +31,13 @@ module Spree
         params
       end
 
-      def assign_to_user_as_default(user:, address_id:)
-        if user.addresses.pluck(:id) == [address_id] # check if it's user first address
-          user.update(bill_address_id: address_id, ship_address_id: address_id)
-        end
+      def assign_to_user_as_default(user:, address_id:, default_billing: true, default_shipping: true)
+        attributes_to_update = {
+          ship_address_id: (address_id if default_shipping),
+          bill_address_id: (address_id if default_billing),
+        }.compact_blank
+
+        user.update_columns(**attributes_to_update, updated_at: Time.current) if attributes_to_update.present?
       end
     end
   end

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

@@ -6,27 +6,94 @@ module Spree
 
       attr_accessor :country
 
-      def call(address:, address_params:)
-        address_params[:country_id] ||= address.country_id
-        address_params = fill_country_and_state_ids(address_params)
-        address_params[:user_id] = address.user_id if address.user_id.present?
+      def call(address:, address_params:, **opts)
+        order = opts[:order]
+        default_billing = opts.fetch(:default_billing, false)
+        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)
 
-        if address&.editable?
-          address.update(address_params) ? success(address) : failure(address)
-        else
-          if new_address(address_params).valid?
-            address.destroy
-            success(new_address)
+        prepare_address_params!(address, address_params)
+        address.assign_attributes(address_params)
+
+        address_changed = address.changes.except(*address_changes_except).any?
+
+        if !address_changed && defaults_changed?(address, default_billing, default_shipping)
+          assign_to_user_as_default(
+            user: address.user,
+            address_id: address.id,
+            default_billing: default_billing,
+            default_shipping: default_shipping
+          )
+        end
+
+        return success(address) unless address_changed
+
+        if address.editable? && !create_new_address_on_update
+          if address.update(address_params)
+            if address.user.present?
+              assign_to_user_as_default(
+                user: address.user,
+                address_id: address.id,
+                default_billing: default_billing,
+                default_shipping: default_shipping
+              )
+            end
+
+            order.update(state: 'address') if order.present?
+
+            success(address)
           else
-            failure(new_address)
+            failure(address)
+          end
+        elsif new_address(address_params).valid?
+          address.destroy unless create_new_address_on_update
+
+          if new_address.user.present?
+            default_billing = (!create_new_address_on_update && address.user_default_billing?) || default_billing
+            default_shipping = (!create_new_address_on_update && address.user_default_shipping?) || default_shipping
+
+            assign_to_user_as_default(
+              user: new_address.user,
+              address_id: new_address.id,
+              default_billing: default_billing,
+              default_shipping: default_shipping
+            )
+          end
+
+          if order.present?
+            order.ship_address = new_address if !create_new_address_on_update && order.ship_address_id == address.id
+            order.bill_address = new_address if !create_new_address_on_update && order.bill_address_id == address.id
+            order.state = 'address'
+            order.save
           end
+
+          success(new_address)
+        else
+          failure(new_address)
         end
       end
 
       private
 
+      def prepare_address_params!(address, address_params)
+        address_params[:user_id] = address&.user_id
+        address_params[:country_id] ||= address.country_id
+        address_params = fill_country_and_state_ids(address_params)
+        address_params.transform_values!(&:presence)
+      end
+
+      def defaults_changed?(address, default_billing, default_shipping)
+        user = address.user
+
+        user.present? && (
+          (default_billing.present? && user.bill_address != address) ||
+          (default_shipping.present? && user.ship_address != address)
+        )
+      end
+
       def new_address(address_params = {})
-        @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
+        @new_address ||= ::Spree::Address.not_deleted.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
       end
     end
   end

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

@@ -0,0 +1,56 @@
+module Spree
+  module Cart
+    class RemoveOutOfStockItems
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:)
+        @messages = []
+        ActiveRecord::Base.transaction do
+          line_items(order).each do |line_item|
+            cart_remove_line_item_service.call(order: order, line_item: line_item) if !valid_status?(line_item) || !stock_available?(line_item)
+          end
+        end
+
+        if @messages.any? # If any line item was removed, reload the order
+          success([order.reload, @messages])
+        else
+          success([order, @messages])
+        end
+      end
+
+      private
+
+      def line_items(order)
+        if order.line_items.empty?
+          []
+        elsif order.line_items.first.association_cached?(:variant) && order.line_items.first.variant.association_cached?(:product)
+          # Don't include associations if it is already included, because it breaks other includes
+          order.line_items
+        else
+          order.line_items.includes(variant: :product)
+        end
+      end
+
+      def valid_status?(line_item)
+        product = line_item.product
+        if !product.active? || product.deleted? || product.discontinued? || line_item.variant.discontinued?
+          @messages << Spree.t('cart_line_item.discontinued', li_name: line_item.name)
+          return false
+        end
+        true
+      end
+
+      def stock_available?(line_item)
+        if line_item.insufficient_stock?
+          @messages << Spree.t('cart_line_item.out_of_stock', li_name: line_item.name)
+          return false
+        end
+        true
+      end
+
+      def cart_remove_line_item_service
+        Spree::Dependencies.cart_remove_line_item_service.constantize
+      end
+    end
+  end
+end

data/app/services/spree/checkout/add_store_credit.rb

@@ -17,7 +17,12 @@ module Spree
           apply_store_credits(remaining_total)
         end
 
-        @order.reload.payments.store_credits.valid.any? ? success(@order) : failure(@order)
+        if @order.reload.payments.store_credits.valid.any?
+          @order.updater.run_hooks
+          success(@order)
+        else
+          failure(@order)
+        end
       end
 
       private

data/app/services/spree/checkout/advance.rb

@@ -3,15 +3,55 @@ module Spree
     class Advance
       prepend Spree::ServiceModule::Base
 
-      def call(order:)
-        Spree::Dependencies.checkout_next_service.constantize.call(order: order) until cannot_make_transition?(order)
+      def call(order:, state: nil, shipping_method_id: nil)
+        return failure(order) if state.present? && !order.has_checkout_step?(state)
+        return success(order) if state.present? && order.passed_checkout_step?(state)
+
+        old_state = order.state
+        order_updater_ran = false
+
+        # We need to check how many times we transitioned between checkout steps and return the error if no transition has been made
+        # We'll always return an error when passing the `state` arg and not reaching the targeted state
+        transitions_count = 0
+
+        until cannot_make_transition?(order, state)
+          next_result = Spree::Dependencies.checkout_next_service.constantize.call(order: order)
+          return failure(order, order.errors) if next_result.failure? && (transitions_count.zero? || state.present?)
+
+          transitions_count +=1
+
+          # Quick Checkout with Google Pay not always sends events for shipping method selection
+          # we have to check this after payment
+
+          if order.delivery? &&
+              shipping_method_id.present? &&
+              order.shipments.count == 1 &&
+              order.shipping_method.id != shipping_method_id
+
+            result = Spree::Checkout::SelectShippingMethod.call(order: order, params: { shipping_method_id: shipping_method_id })
+
+            # We're running the order update inside Spree::Checkout::SelectShippingMethod
+            order_updater_ran = result.success?
+          end
+        end
+
+        if order.state != old_state && !order_updater_ran
+          order.updater.update_shipment_state
+          order.updater.update_payment_state
+          order.save! if order.changed?
+        end
+
         success(order)
       end
 
       private
 
-      def cannot_make_transition?(order)
-        order.confirm? || order.complete? || order.errors.present?
+      def cannot_make_transition?(order, state = nil)
+        order.state == state || order.confirm? || order.complete? || order.errors.present? || order.passed_checkout_step?(state)
+      end
+
+      def report_advance_error(error, order)
+        # You can report checkout advance error here
       end
     end
   end

data/app/services/spree/checkout/select_shipping_method.rb

@@ -26,6 +26,8 @@ module Spree
           end
         end
 
+        order.update_with_updater!
+
         success(order)
       end
 

data/app/services/spree/coupon_codes/bulk_generate.rb

@@ -0,0 +1,37 @@
+module Spree
+  module CouponCodes
+    class BulkGenerate
+      prepend Spree::ServiceModule::Base
+
+      def call(promotion:, quantity: 10)
+        coupon_codes = []
+
+        Spree::CouponCode.transaction do
+          quantity.times do
+            coupon_codes << coupon_attributes(promotion).merge(code: create_code(promotion.code_prefix))
+          end
+          Spree::CouponCode.insert_all coupon_codes
+        end
+
+        success(promotion.reload.coupon_codes)
+      end
+
+      private
+
+      def create_code(prefix = nil)
+        loop do
+          code = "#{prefix}#{SecureRandom.hex(8)}".downcase
+          break code unless Spree::CouponCode.exists?(code: code)
+        end
+      end
+
+      def coupon_attributes(promotion)
+        {
+          promotion_id: promotion.id,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+    end
+  end
+end

data/app/services/spree/coupon_codes/coupon_codes_handler.rb

@@ -0,0 +1,34 @@
+module Spree
+  module CouponCodes
+    class CouponCodesHandler
+      attr_reader :order, :codes
+
+      def initialize(order:)
+        @order = order
+        @codes = Spree::CouponCode.where(order_id: order.id)
+      end
+
+      def use_all_codes
+        return unless codes.any?
+
+        promotion_ids = find_current_promotions_ids
+        use_all_current(promotion_ids)
+        clear_all_unused(promotion_ids)
+      end
+
+      private
+
+      def find_current_promotions_ids
+        order.all_adjustments.promotion.eligible.map { |a| a.source.try(:promotion_id) }.compact
+      end
+
+      def use_all_current(promotion_ids)
+        codes.in_promotions(promotion_ids).update_all(state: 1)
+      end
+
+      def clear_all_unused(promotion_ids)
+        codes.not_in_promotions(promotion_ids).update_all(order_id: nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# this service creates a user account when someone places an order
+# and checks the box to create an account
+module Spree
+  module Orders
+    class CreateUserAccount
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:, accepts_email_marketing: false)
+        existing_user = Spree.user_class.find_by(email: order.email)
+        return existing_user if existing_user.present?
+
+        user = create_new_user(order, accepts_email_marketing)
+        return failure(:user_creation_failed) unless user.persisted?
+
+        assign_ship_address(order, user)
+        assign_bill_address(order, user)
+
+        # assign newly created user to the order
+        # using update_columns to avoid running validations/callbacks
+        order.update_columns(user_id: user.id, updated_at: Time.current)
+        order.user = user
+
+        # send welcome email
+        user.send_welcome_email if user.respond_to?(:send_welcome_email)
+
+        success(user.reload)
+      end
+
+      private
+
+      def create_new_user(order, accepts_email_marketing = false)
+        firstname = order.bill_address&.firstname || order.ship_address&.firstname
+        lastname = order.bill_address&.lastname || order.ship_address&.lastname
+        phone = order.bill_address&.phone || order.ship_address&.phone
+
+        # we need to generate a password for the user
+        password = SecureRandom.base58(16)
+
+        user = Spree.user_class.new
+        user.email = order.email
+        user.first_name = firstname if user.respond_to?(:first_name)
+        user.last_name = lastname if user.respond_to?(:last_name)
+        user.phone = phone if user.respond_to?(:phone)
+        user.accepts_email_marketing = accepts_email_marketing.to_b if user.respond_to?(:accepts_email_marketing)
+        user.password = password if user.respond_to?(:password)
+        user.password_confirmation = password if user.respond_to?(:password_confirmation)
+
+        user.save
+
+        user
+      end
+
+      def assign_bill_address(order, user)
+        if order.bill_address.present?
+          order.bill_address.update_columns(user_id: user.id, updated_at: Time.current)
+
+          user.update_columns(bill_address_id: order.bill_address_id, updated_at: Time.current) unless user.bill_address_id.present?
+        end
+      end
+
+      def assign_ship_address(order, user)
+        if order.ship_address.present?
+          order.ship_address.update_columns(user_id: user.id, updated_at: Time.current)
+
+          user.update_columns(ship_address_id: order.ship_address_id, updated_at: Time.current) unless user.ship_address_id.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Orders
+    class UpdateContactInformation
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:, order_params:)
+        ActiveRecord::Base.transaction do
+          order.update_columns(email: order_params[:email], updated_at: Time.current)
+
+          if order.respond_to?(:vendor_orders) && order.vendor_orders.any?
+            order.vendor_orders.update_all(email: order_params[:email], updated_at: Time.current)
+          end
+        end
+
+        success(order.reload)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Spree
+  module Products
+    class AutoMatchTaxons
+      prepend ::Spree::ServiceModule::Base
+
+      def call(product:)
+        return unless product.present?
+
+        taxons_to_remove = []
+        taxons_to_add = []
+
+        # we need to check if existing taxons still match
+        product.taxons.automatic.includes(:taxon_rules).each do |taxon|
+          # products shouldn't be part of the taxon anymore
+          # eg. product tags or category was changed
+          taxons_to_remove << taxon unless taxon.products_matching_rules.ids.include?(product.id)
+        end
+
+        Spree::Classification.where(taxon: taxons_to_remove, product: product).delete_all if taxons_to_remove.any?
+
+        # we need to check if product matches any existing taxons
+        Spree::Taxon.automatic.includes(:taxon_rules, :products).each do |taxon|
+          taxons_to_add << taxon if taxon.products.exclude?(product) && taxon.products_matching_rules.ids.include?(product.id)
+        end
+
+        if taxons_to_add.any?
+          products_counts = Spree::Taxon.where(id: taxons_to_add.pluck(:id)).
+                            joins(:classifications).
+                            reorder('').
+                            group(:taxon_id).
+                            count(:product_id)
+
+          Spree::Classification.insert_all(
+            taxons_to_add.map do |taxon|
+              position = products_counts[taxon.id].to_i + 1
+              classification_attributes(taxon, product, position)
+            end
+          )
+        end
+
+        all_affected_taxons = (taxons_to_remove + taxons_to_add).uniq
+
+        if all_affected_taxons.any?
+          Spree::Taxons::TouchFeaturedSections.call(taxon_ids: all_affected_taxons.pluck(:id))
+          product.touch
+        end
+
+        success(product)
+      end
+
+      private
+
+      def classification_attributes(taxon, product, position)
+        {
+          taxon_id: taxon.id,
+          product_id: product.id,
+          position: position,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+    end
+  end
+end