spree_core 4.2.5 → 4.3.0

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

@@ -0,0 +1,22 @@
+module Spree
+  module Filters
+    class PricePresenter
+      def initialize(amount:, currency:)
+        @amount = amount.to_i
+        @currency = currency
+      end
+
+      def to_i
+        amount
+      end
+
+      def to_s
+        Spree::Money.new(amount, currency: currency, no_cents_if_whole: true).to_s
+      end
+
+      private
+
+      attr_reader :amount, :currency
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Filters
+    class PriceRangePresenter
+      def self.from_param(param, currency:)
+        prices = param.split('-')
+
+        new(
+          min_price: PricePresenter.new(amount: prices.first, currency: currency),
+          max_price: PricePresenter.new(amount: prices.last, currency: currency)
+        )
+      end
+
+      def initialize(min_price:, max_price:)
+        @min_price = min_price
+        @max_price = max_price
+      end
+
+      attr_reader :min_price, :max_price
+
+      def to_param
+        "#{min_price.to_i}-#{max_price.to_i}"
+      end
+
+      def to_s
+        "#{min_price} - #{max_price}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Filters
+    class PropertiesPresenter
+      def initialize(product_properties_scope:)
+        @product_properties = product_properties_scope.includes(:property)
+      end
+
+      def to_a
+        grouped_options.map do |property, product_properties|
+          PropertyPresenter.new(property: property, product_properties: product_properties)
+        end
+      end
+
+      private
+
+      attr_reader :product_properties
+
+      def grouped_options
+        product_properties.group_by(&:property)
+      end
+    end
+  end
+end

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/services/spree/account/addresses/create.rb

@@ -12,6 +12,7 @@ module Spree
 
           address = user.addresses.new(address_params)
           if address.save
+            assign_to_user_as_default(user: user, address_id: address.id)
             success(address)
           else
             failure(address)

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

@@ -31,6 +31,12 @@ module Spree
           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/account/addresses/update.rb

@@ -11,12 +11,18 @@ module Spree
           address_params[:country_id] ||= address.country_id
           fill_country_and_state_ids(address_params)
 
-          if address.update(address_params)
-            success(address)
+          if address&.editable?
+            address.update(address_params) ? success(address) : failure(address)
           else
-            failure(address)
+            new_address(address_params).valid? ? address.destroy && success(new_address) : failure(new_address)
           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/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/build_localized_redirect_url.rb

@@ -6,7 +6,7 @@ module Spree
 
     LOCALE_REGEX = /^\/[A-Za-z]{2}\/|^\/[A-Za-z]{2}-[A-Za-z]{2}\/|^\/[A-Za-z]{2}$|^\/[A-Za-z]{2}-[A-Za-z]{2}$/.freeze
 
-    SUPPORTED_PATHS_REGEX = /\/(products|t\/|cart|checkout|addresses|content)/.freeze
+    SUPPORTED_PATHS_REGEX = /\/(#{Spree::Config[:storefront_products_path]}|#{Spree::Config[:storefront_taxons_path]}\/|cart|checkout|addresses|content|#{Spree::Config[:storefront_pages_path]})/.freeze
 
     # rubocop:disable Lint/UnusedMethodArgument
     def call(url:, locale:, default_locale: nil)

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

@@ -6,14 +6,16 @@ module Spree
       def call(user:, store:, currency:, order_params: nil)
         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,
+          currency: currency || store.default_currency,
           token: Spree::GenerateToken.new.call(Spree::Order)
         }
 
-        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::Config[:default_country_id]
+          store.default_country_id
         end
       end
 

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

@@ -23,7 +23,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/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