spree_core 4.1.1 → 4.5.0

data/app/presenters/spree/filters/property_presenter.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Filters
+    class PropertyPresenter
+      def initialize(property:, product_properties:)
+        @property = property
+        @product_properties = product_properties
+      end
+
+      attr_reader :product_properties
+
+      delegate_missing_to :property
+
+      def uniq_values
+        property.uniq_values(product_properties_scope: product_properties)
+      end
+
+      def to_h
+        {
+          id: property.id,
+          name: property.name,
+          presentation: property.presentation,
+          values: values_hash
+        }
+      end
+
+      private
+
+      attr_reader :property
+
+      def values_hash
+        value_hashes = uniq_values.map do |filter_param, value|
+          {
+            value: value,
+            filter_param: filter_param
+          }
+        end
+
+        value_hashes.sort_by { |e| e[:value] }
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/quantified_price_range_presenter.rb

@@ -0,0 +1,44 @@
+module Spree
+  module Filters
+    class QuantifiedPriceRangePresenter
+      ALLOWED_QUANTIFIERS = [
+        :less_than,
+        :more_than
+      ].freeze
+
+      def initialize(price:, quantifier:)
+        if ALLOWED_QUANTIFIERS.exclude?(quantifier.to_sym)
+          raise ArgumentError, "quantifier must be one of: #{ALLOWED_QUANTIFIERS.join(', ')}"
+        end
+
+        @price = price
+        @quantifier = quantifier.to_sym
+      end
+
+      def to_param
+        case quantifier
+        when :less_than
+          less_than_param
+        when :more_than
+          more_than_param
+        end
+      end
+
+      def to_s
+        "#{I18n.t("activerecord.attributes.spree/product.#{quantifier}")} #{price}"
+      end
+
+      private
+
+      attr_reader :price, :quantifier
+
+      def less_than_param
+        "0-#{price.to_i}"
+      end
+
+      def more_than_param
+        "#{price.to_i}-Infinity"
+      end
+    end
+  end
+end

data/app/presenters/spree/variant_presenter.rb

@@ -2,20 +2,25 @@ module Spree
   class VariantPresenter
     include Rails.application.routes.url_helpers
     include Spree::BaseHelper
+    include Spree::ProductsHelper
 
-    attr_reader :current_currency, :current_price_options
+    attr_reader :current_currency, :current_price_options, :current_store
 
     def initialize(opts = {})
       @variants = opts[:variants]
       @is_product_available_in_currency = opts[:is_product_available_in_currency]
       @current_currency = opts[:current_currency]
       @current_price_options = opts[:current_price_options]
+      @current_store = opts[:current_store]
     end
 
     def call
       @variants.map do |variant|
         {
           display_price: display_price(variant),
+          price: variant.price_in(current_currency),
+          display_compare_at_price: display_compare_at_price(variant),
+          should_display_compare_at_price: should_display_compare_at_price?(variant),
           is_product_available_in_currency: @is_product_available_in_currency,
           backorderable: backorderable?(variant),
           in_stock: in_stock?(variant),

data/app/presenters/spree/variants/option_types_presenter.rb

@@ -76,6 +76,7 @@ module Spree
             id: option_value.id,
             position: option_value.position,
             presentation: option_value.presentation,
+            name: option_value.name,
             variant_id: option_value.variants.where(id: @variant_ids).order(:position).first.id,
             is_default: option_value == default_variant_data[:option_value]
           }

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

@@ -0,0 +1,8 @@
+module Spree
+  module Account
+    module Addresses
+      class Create < Spree::Addresses::Create
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Spree
+  module Account
+    module Addresses
+      class Update < Spree::Addresses::Update
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Spree
+  module Account
+    class Create
+      prepend Spree::ServiceModule::Base
+
+      def call(user_params: {})
+        user = Spree.user_class.new(user_params)
+
+        if user.save
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Spree
+  module Account
+    class Update
+      prepend Spree::ServiceModule::Base
+
+      def call(user:, user_params: {})
+        if user.update(user_params)
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  module Addresses
+    class Create
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address_params: {}, user: nil)
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Spree
+  module Addresses
+    module Helper
+      private
+
+      attr_accessor :country
+
+      def fill_country_and_state_ids(params)
+        replace_country_iso_with_id(params)
+        fill_state_id(params)
+      end
+
+      def replace_country_iso_with_id(params)
+        iso = params[:country_iso]
+        return params unless iso.present?
+
+        country = Spree::Country.by_iso(iso)
+        params[:country_id] = country&.id
+        params.delete(:country_iso)
+        params
+      end
+
+      def fill_state_id(params)
+        state_name = params[:state_name]
+        return params unless state_name.present?
+
+        country ||= Spree::Country.find(params[:country_id]) if params[:country_id].present?
+        return params unless country
+
+        params[:state_id] = country.states.find_by(name: state_name)&.id
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Spree
+  module Addresses
+    class Update
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address:, address_params:)
+        address_params[:country_id] ||= address.country_id
+        address_params = fill_country_and_state_ids(address_params)
+
+        if address&.editable?
+          address.update(address_params) ? success(address) : failure(address)
+        else
+          if new_address(address_params).valid?
+            address.destroy
+            success(new_address)
+          else
+            failure(new_address)
+          end
+        end
+      end
+
+      private
+
+      def new_address(address_params = {})
+        @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Spree
     class AddItem
       prepend Spree::ServiceModule::Base
 
-      def call(order:, variant:, quantity: nil, options: {})
+      def call(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         ApplicationRecord.transaction do
           run :add_to_line_item
           run Spree::Dependencies.cart_recalculate_service.constantize
@@ -12,7 +12,7 @@ module Spree
 
       private
 
-      def add_to_line_item(order:, variant:, quantity: nil, options: {})
+      def add_to_line_item(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         options ||= {}
         quantity ||= 1
 
@@ -32,6 +32,8 @@ module Spree
         end
 
         line_item.target_shipment = options[:shipment] if options.key? :shipment
+        line_item.public_metadata = public_metadata.to_h if public_metadata
+        line_item.private_metadata = private_metadata.to_h if private_metadata
 
         return failure(line_item) unless line_item.save
 

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

@@ -0,0 +1,16 @@
+module Spree
+  module Cart
+    class Associate
+      prepend Spree::ServiceModule::Base
+
+      def call(guest_order:, user:)
+        if guest_order.user.nil?
+          guest_order.associate_user!(user)
+          success(guest_order)
+        else
+          failure(guest_order, 'Already assigned to a user')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Spree
+  module Cart
+    class ChangeCurrency
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, new_currency:)
+        return failure('Currency not supported') unless supported_currency?(order, new_currency)
+
+        result = order.update!(currency: new_currency) rescue false
+
+        if result
+          success(order)
+        else
+          failure('Failed to update order')
+        end
+      end
+
+      private
+
+      def supported_currency?(order, currency)
+        store = order.store
+        supported_currencies = store.supported_currencies_list
+        supported_currencies.map(&:iso_code).include?(currency.upcase)
+      end
+    end
+  end
+end

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

@@ -3,17 +3,21 @@ module Spree
     class Create
       prepend Spree::ServiceModule::Base
 
-      def call(user:, store:, currency:, order_params: nil)
+      def call(user:, store:, currency:, public_metadata: {}, private_metadata: {}, order_params: {})
         order_params ||= {}
 
+        # we cannot create an order without store
+        return failure(:store_is_required) if store.nil?
+
         default_params = {
           user: user,
-          store: store,
-          currency: currency,
-          token: Spree::GenerateToken.new.call(Spree::Order)
+          currency: currency || store.default_currency,
+          token: Spree::GenerateToken.new.call(Spree::Order),
+          public_metadata: public_metadata.to_h,
+          private_metadata: private_metadata.to_h
         }
 
-        order = Spree::Order.create!(default_params.merge(order_params))
+        order = store.orders.create!(default_params.merge(order_params))
         success(order)
       end
     end

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

@@ -0,0 +1,40 @@
+module Spree
+  module Cart
+    class Destroy
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        run :check_if_can_be_destroyed
+        run :cancel_shipments
+        run :void_payments
+        run :destroy_order
+      end
+
+      private
+
+      def check_if_can_be_destroyed(order:)
+        return failure(Spree.t(:cannot_be_destroyed)) unless order&.can_be_destroyed?
+
+        success(order: order)
+      end
+
+      def cancel_shipments(order:)
+        order.shipments.each(&:cancel!)
+
+        success(order: order)
+      end
+
+      def void_payments(order:)
+        order.payments.each(&:void!)
+
+        success(order: order)
+      end
+
+      def destroy_order(order:)
+        order.destroy
+
+        success(order)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Spree
+  module Cart
+    class Empty
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        run :check_if_can_be_empty
+        run :empty_order
+      end
+
+      private
+
+      def check_if_can_be_empty(order:)
+        return failure(Spree.t(:cannot_empty)) if order.nil? || order.completed?
+
+        success(order: order)
+      end
+
+      def empty_order(order:)
+        ActiveRecord::Base.transaction do
+          order.line_items.destroy_all
+          order.updater.update_item_count
+          order.adjustments.destroy_all
+          order.shipments.destroy_all
+          order.state_changes.destroy_all
+          order.order_promotions.destroy_all
+          order.update_totals
+          order.persist_totals
+          order.restart_checkout_flow
+
+          success(order)
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(order:, country_iso: nil)
-        country_id = country_id(country_iso)
+        country_id = country_id(order.store, country_iso)
         dummy_order = generate_dummy_order(order, country_id)
 
         packages = ::Spree::Stock::Coordinator.new(dummy_order).packages
@@ -20,11 +20,11 @@ module Spree
 
       private
 
-      def country_id(country_iso)
+      def country_id(store, country_iso)
         if country_iso.present?
           ::Spree::Country.by_iso(country_iso)&.id
         else
-          ::Spree::Country.default.id
+          store.default_country_id
         end
       end
 

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

@@ -11,6 +11,7 @@ module Spree
                                                                             line_item: line_item,
                                                                             options: options)
         end
+        order.reload
         success(line_item)
       end
     end

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

@@ -25,10 +25,10 @@ module Spree
       def filter_order_items(order, params)
         return params if params[:line_items_attributes].nil? || params[:line_items_attributes][:id]
 
-        line_item_ids = order.line_items.pluck(:id)
+        line_item_ids = order.line_item_ids.map(&:to_s)
 
         params[:line_items_attributes].each_pair do |id, value|
-          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
+          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_s) || value[:variant_id].present?
         end
         params
       end

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

@@ -9,9 +9,12 @@ module Spree
 
         remaining_total = amount ? [amount, @order.outstanding_balance].min : @order.outstanding_balance
 
+        return failure(nil, Spree.t(:error_user_does_not_have_any_store_credits)) unless @order.user&.store_credits&.any?
+
         ApplicationRecord.transaction do
           @order.payments.store_credits.where(state: :checkout).map(&:invalidate!)
-          apply_store_credits(remaining_total) if @order.user&.store_credits&.any?
+
+          apply_store_credits(remaining_total)
         end
 
         @order.reload.payments.store_credits.valid.any? ? success(@order) : failure(@order)
@@ -23,7 +26,7 @@ module Spree
         payment_method = Spree::PaymentMethod::StoreCredit.available.first
         raise 'Store credit payment method could not be found' unless payment_method
 
-        @order.user.store_credits.order_by_priority.each do |credit|
+        @order.user.store_credits.for_store(@order.store).order_by_priority.each do |credit|
           break if remaining_total.zero?
           next if credit.amount_remaining.zero?
 

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

@@ -7,9 +7,7 @@ module Spree
         run :reload_order
         run :ensure_shipping_address
         run :ensure_line_items_present
-        run :move_order_to_delivery_state
-        run :generate_shipping_rates
-        run :return_shipments
+        run :generate_or_return_shipping_rates
       end
 
       private
@@ -31,6 +29,11 @@ module Spree
         success(order: order)
       end
 
+      def generate_or_return_shipping_rates(order:)
+        generate_shipping_rates(order: order) if order.shipments.empty?
+        return_shipments(order: order)
+      end
+
       def generate_shipping_rates(order:)
         ApplicationRecord.transaction do
           order.create_proposed_shipments
@@ -42,13 +45,7 @@ module Spree
       end
 
       def return_shipments(order:)
-        success(order.shipments.includes([shipping_rates: :shipping_method]))
-      end
-
-      def move_order_to_delivery_state(order:)
-        Spree::Dependencies.checkout_next_service.constantize.call(order: order) until order.state == 'delivery'
-
-        success(order: order)
+        success(order.reload.shipments.includes([shipping_rates: :shipping_method]))
       end
     end
   end

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

@@ -0,0 +1,49 @@
+module Spree
+  module Checkout
+    class SelectShippingMethod
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, params:)
+        if params[:shipment_id].present?
+          shipment = order.shipments.valid.find_by(id: params[:shipment_id])
+          return failure(:shipment_not_found) if shipment.nil?
+        end
+
+        shipping_method = Spree::ShippingMethod.find_by(id: params[:shipping_method_id])
+        return failure(:shipping_method_not_found) if shipping_method.nil?
+
+        # single shipment passed
+        if shipment.present?
+          result = set_shipping_rate_based_on_method(shipment: shipment, shipping_method: shipping_method)
+
+          return failure(result.value, result.error) unless result.success?
+        else
+          # set shipping method for all shipments
+          order.shipments.valid.each do |s|
+            result = set_shipping_rate_based_on_method(shipment: s, shipping_method: shipping_method)
+
+            return failure(result.value, result.error) unless result.success?
+          end
+        end
+
+        success(order)
+      end
+
+      def set_shipping_rate_based_on_method(shipment:, shipping_method:)
+        selected_shipping_rate = shipment.shipping_rates.find_by(shipping_method: shipping_method)
+
+        if selected_shipping_rate.nil?
+          return failure(
+            :selected_shipping_method_not_found,
+            "Couldn't find shipping rates for Shipping Method with ID = #{shipping_method.id} and Shipment with ID = #{shipment.id}"
+          )
+        end
+
+        shipment.selected_shipping_rate_id = selected_shipping_rate.id
+        shipment.update_amounts
+
+        success(shipment)
+      end
+    end
+  end
+end

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

@@ -2,10 +2,15 @@ module Spree
   module Checkout
     class Update
       prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
 
       def call(order:, params:, permitted_attributes:, request_env:)
-        params = replace_country_iso_with_id(params, 'ship') if address_with_country_iso_present?(params, 'ship')
-        params = replace_country_iso_with_id(params, 'bill') if address_with_country_iso_present?(params, 'bill')
+        ship_changed = address_with_country_iso_present?(params, 'ship')
+        bill_changed = address_with_country_iso_present?(params, 'bill')
+        params[:order][:ship_address_attributes] = replace_country_iso_with_id(params[:order][:ship_address_attributes]) if ship_changed
+        params[:order][:bill_address_attributes] = replace_country_iso_with_id(params[:order][:bill_address_attributes]) if bill_changed
+        order.state = 'address' if (ship_changed || bill_changed) && order.has_checkout_step?('address')
+        order.state = 'delivery' if selected_shipping_rate_present?(params) && order.has_checkout_step?('delivery')
         return success(order) if order.update_from_params(params, permitted_attributes, request_env)
 
         failure(order)
@@ -20,12 +25,11 @@ module Spree
         true
       end
 
-      def replace_country_iso_with_id(params, address_kind = 'ship')
-        country_id = Spree::Country.by_iso(params[:order]["#{address_kind}_address_attributes"].fetch(:country_iso))&.id
+      def selected_shipping_rate_present?(params)
+        shipments_attributes = params.dig(:order, :shipments_attributes)
+        return false unless shipments_attributes
 
-        params[:order]["#{address_kind}_address_attributes"]['country_id'] = country_id
-        params[:order]["#{address_kind}_address_attributes"].delete(:country_iso)
-        params
+        shipments_attributes.any? { |s| s.dig(:selected_shipping_rate_id) }
       end
     end
   end

data/app/services/spree/classifications/reposition.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Classifications
+    class Reposition
+      prepend Spree::ServiceModule::Base
+
+      def call(classification:, position:)
+        if position.is_a?(String) && !position.match(/^\d+$/)
+          return failure(nil, I18n.t('errors.messages.not_a_number'))
+        end
+
+        # Because position we get back is 0-indexed.
+        # acts_as_list is 1-indexed.
+        classification.insert_at(position.to_i + 1)
+        success(classification)
+      end
+    end
+  end
+end