spree_core 4.2.7 → 4.3.0.rc1

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,22 @@
+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
+
+      private
+
+      attr_reader :property
+    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/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

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

@@ -0,0 +1,41 @@
+module Spree
+  module CreditCards
+    class Destroy
+      prepend Spree::ServiceModule::Base
+
+      def call(card:)
+        ApplicationRecord.transaction do
+          run :invalidate_payments
+          run :void_payments
+          run :destroy
+        end
+      end
+
+      protected
+
+      def invalidate_payments(card:)
+        payment_scope(card).checkout.each(&:invalidate!)
+
+        success(card: card)
+      end
+
+      def void_payments(card:)
+        payment_scope(card).where.not(state: :checkout).each(&:void!)
+
+        success(card: card)
+      end
+
+      def destroy(card:)
+        if card.destroy
+          success(card: card)
+        else
+          failure(card.errors.full_messages.to_sentance)
+        end
+      end
+
+      def payment_scope(card)
+        card.payments.valid.joins(:order).merge(Spree::Order.incomplete)
+      end
+    end
+  end
+end

data/app/validators/db_maximum_length_validator.rb

@@ -2,6 +2,11 @@
 # Validates a field based on the maximum length of the underlying DB field, if there is one.
 class DbMaximumLengthValidator < ActiveModel::EachValidator
   def validate_each(record, attribute, value)
+    ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+      `DbMaximumLengthValidator` is deprecated and will be removed in Spree 5.0.
+      Please remove any `db_maximum_length: true` validations from your codebase
+    DEPRECATION
+
     limit = if defined?(Globalize)
               record.class.translation_class.columns_hash[attribute.to_s].limit
             else

data/app/validators/email_validator.rb

@@ -1,6 +1,8 @@
 class EmailValidator < ActiveModel::EachValidator
+  EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+
   def validate_each(record, attribute, value)
-    unless value =~ /\A[^@\s]+@[^@\s]+\z/
+    unless value =~ EMAIL_REGEX
       record.errors.add(attribute, :invalid, **{ value: value }.merge!(options))
     end
   end

data/app/views/spree/shared/_purchased_items_table.text.erb

@@ -0,0 +1,25 @@
+<% line_items.each do |item| %>
+  <%= item.variant.sku %> <%= raw(item.variant.product.name) %> <%= raw(item.variant.options_text) -%> (<%=item.quantity%>) <%= Spree.t('at_symbol') %> <%= item.single_money %> = <%= item.display_amount %>
+<% end %>
+============================================================
+<%= Spree.t('order_mailer.subtotal') %> <%= order.display_item_total %>
+<% if order.line_item_adjustments.exists? %>
+  <% if order.all_adjustments.promotion.eligible.exists? %>
+    <% order.all_adjustments.promotion.eligible.group_by(&:label).each do |label, adjustments| %>
+      <%= Spree.t(:promotion) %>: <%= label %> <%= Spree::Money.new(adjustments.sum(&:amount), currency: order.currency) %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% order.shipments.group_by { |s| s.selected_shipping_rate.try(:name) }.each do |name, shipments| %>
+  <%= Spree.t(:shipping) %>: <%= name %> <%= Spree::Money.new(shipments.sum(&:discounted_cost), currency: order.currency) %>
+<% end %>
+
+<% if order.additional_tax_total != 0 %>
+  <%= Spree.t(:tax) %>: <%= order.display_additional_tax_total.to_html %>
+<% end %>
+
+<% order.adjustments.eligible.each do |adjustment| %>
+  <% next if (adjustment.source_type == 'Spree::TaxRate') and (adjustment.amount == 0) %>
+  <%= adjustment.label %> <%= adjustment.display_amount %>
+<% end %>

data/config/initializers/active_storage.rb

@@ -3,3 +3,5 @@ class ActiveStorage::PurgeJob < ActiveStorage::BaseJob
     blob.purge unless blob.attachments.present?
   end
 end
+
+Rails.application.config.active_storage.content_types_to_serve_as_binary.delete('image/svg+xml')