spree_storefront 5.0.0.rc1

data/app/controllers/spree/store_controller.rb

@@ -0,0 +1,247 @@
+module Spree
+  class StoreController < BaseController
+    include Spree::Core::ControllerHelpers::Order
+
+    include Spree::LocaleUrls
+    include Spree::ThemeConcern
+    include Spree::StorefrontHelper
+    include Spree::PasswordProtected
+    include Spree::WishlistHelper
+    include Spree::AnalyticsHelper
+
+    layout :choose_layout
+
+    helper 'spree/base'
+    helper 'spree/locale'
+    helper 'spree/storefront_locale'
+    helper 'spree/currency'
+    helper 'spree/addresses'
+    helper 'spree/wishlist'
+
+    helper_method :title
+    helper_method :title=
+    helper_method :accurate_title
+
+    helper_method :current_taxon, :store_filter_names
+
+    helper_method :permitted_products_params, :products_filters_params,
+                  :storefront_products_scope, :storefront_products,
+                  :default_products_sort, :default_products_finder_params
+
+    before_action :redirect_to_default_locale
+    before_action :render_404_if_store_not_exists
+    rescue_from ActionController::InvalidAuthenticityToken, with: :invalid_authenticity_token
+
+    def render_404_if_store_not_exists
+      return if current_store.present?
+
+      render 'errors/404', layout: 'application', status: :not_found
+    end
+
+    def current_taxon
+      @current_taxon ||= (current_store.taxons.find_by(id: params[:taxon_id]) if params[:taxon_id].present?)
+    end
+
+    def store_filter_names
+      @store_filter_names ||= Spree::OptionType.filterable.order(:position).pluck(:name)
+    end
+
+    def store_filter_names_hash
+      filter_names = {}
+      store_filter_names.each do |filter_name|
+        filter_names[filter_name.to_sym] = []
+      end
+      filter_names
+    end
+
+    def permitted_products_params
+      @permitted_products_params ||= params.permit(
+        :locale,
+        :currency,
+        :q,
+        :page,
+        :per_page,
+        :sort_by,
+        filter: [
+          :min_price,
+          :max_price,
+          :purchasable,
+          :out_of_stock,
+          {
+            options: [store_filter_names_hash],
+            taxon_ids: []
+          }
+        ]
+      )
+    end
+
+    def default_products_sort
+      'manual'
+    end
+
+    def products_filters_params
+      @products_filters_params ||= permitted_products_params[:filter]&.compact_blank || {}
+    end
+
+    protected
+
+    def choose_layout
+      if turbo_frame_request? && !current_theme_preview.present?
+        'turbo_rails/frame'
+      else
+        'spree/storefront'
+      end
+    end
+
+    # can be used in views as well as controllers.
+    # e.g. <% self.title = 'This is a custom title for this view' %>
+    attr_writer :title
+
+    def title
+      title_string = @title.present? ? @title : accurate_title
+      if title_string.present?
+        title_string
+      else
+        default_title
+      end
+    end
+
+    def default_title
+      @default_title ||= current_store.name
+    end
+
+    # this is a hook for subclasses to provide title
+    def accurate_title
+      @accurate_title ||= current_store.seo_title.presence || current_store.name
+    end
+
+    def storefront_products_scope
+      current_store.products.active(current_currency)
+    end
+
+    def default_products_finder_params
+      taxon = @taxon || current_taxon
+
+      filter = permitted_products_params.fetch(:filter, {}).dup
+
+      filter[:taxon_ids] ||= [taxon&.id.to_s].compact
+      filter[:taxons] = filter[:taxon_ids].join(',')
+
+      if filter.key?(:min_price) || filter.key?(:max_price)
+        min_price = filter[:min_price].presence || 0
+        max_price = filter[:max_price].presence || 'Infinity'
+
+        filter[:price] = [min_price, max_price].compact.join(',')
+      end
+
+      permitted_products_params.merge(
+        store: current_store,
+        filter: filter,
+        currency: current_currency
+      )
+    end
+
+    def storefront_products
+      @storefront_products ||= begin
+        finder_params = default_products_finder_params
+        finder_params[:sort_by] ||= @taxon&.sort_order || 'manual'
+
+        products_finder = Spree::Dependencies.products_finder.constantize
+        products = products_finder.
+                   new(scope: storefront_products_scope, params: finder_params).
+                   execute.
+                   includes(storefront_products_includes)
+
+        default_per_page = Spree::Storefront::Config[:products_per_page]
+        per_page = params[:per_page].present? ? params[:per_page].to_i : default_per_page
+        page = params[:page].present? ? params[:page].to_i : 1
+
+        products.page(page).per(per_page)
+      end
+    end
+
+    def storefront_products_includes
+      [
+        :prices_including_master,
+        :variant_images,
+        :option_types,
+        :option_values,
+        { master: [:images, :prices, :stock_items, :stock_locations, { stock_items: :stock_location }],
+          variants: [
+            :images, :prices, :option_values, :stock_items, :stock_locations,
+            { option_values: :option_type, stock_items: :stock_location }
+          ],
+          taxons: [:taxonomy],
+          taggings: [:tag] }
+      ]
+    end
+
+    def redirect_unauthorized_access
+      if try_spree_current_user
+        flash[:error] = Spree.t(:authorization_failure)
+        redirect_to spree.forbidden_path
+      else
+        store_location
+        if respond_to?(:spree_login_path)
+          redirect_to spree_login_path
+        else
+          redirect_to spree.root_path
+        end
+      end
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(session[:user_return_to] || default)
+    end
+
+    def require_user(return_to = nil)
+      return if try_spree_current_user
+
+      store_location(return_to)
+
+      respond_to do |format|
+        format.html { redirect_to spree_login_path }
+        format.turbo_stream { render turbo_stream: turbo_stream.slideover_open('slideover-account', 'account-pane') }
+      end
+    end
+
+    # this will work for devise out of the box
+    # for other auth systems you will need to override this method
+    def store_location(location = nil)
+      return if try_spree_current_user
+      return unless defined?(store_location_for)
+      return unless defined?(Devise)
+
+      location ||= request.fullpath
+
+      store_location_for(Devise.mappings.keys.first, location)
+    end
+
+    def redirect_to_cart
+      redirect_to spree.cart_path
+    end
+
+    def clear_order_token
+      cookies.delete(:token)
+    end
+
+    def disable_sesion_tracking
+      request.session_options[:skip] = true
+    end
+
+    def invalid_authenticity_token(exception)
+      Rails.error.report(
+        exception,
+        context: { user_id: spree_current_user&.id },
+        source: 'spree.storefront'
+      )
+
+      flash[:error] = Spree.t(:something_went_wrong)
+
+      respond_to do |format|
+        format.html { redirect_back_or_to root_path }
+        format.turbo_stream { render turbo_stream: turbo_stream.update('flash', partial: 'spree/shared/flashes') }
+      end
+    end
+  end
+end

data/app/controllers/spree/taxonomies_controller.rb

@@ -0,0 +1,30 @@
+module Spree
+  class TaxonomiesController < Spree::StoreController
+    def show
+      @taxonomy = current_store.taxons.where(parent_id: nil).friendly.find(params[:id])
+
+      @taxons = @taxonomy.children.order(name: :asc)
+      taxons_grouped = @taxons.group_by { |b| b.name[0].upcase }
+
+      numbers = ('0'..'9').to_a
+      alphabet_letters = ('A'..'Z').to_a
+
+      @taxons_grouped_by_letter = begin
+        taxons_grouped_by_letter = {}
+        alphabet_letters.each do |letter|
+          taxons_grouped_by_letter[letter] = taxons_grouped[letter]
+        end
+        taxons_grouped_by_letter
+      end
+
+      @taxons_grouped_by_numbers = taxons_grouped.select { |k, _v| numbers.include?(k) }
+      @taxons_grouped_by_other = taxons_grouped.select { |k, _v| alphabet_letters.concat(numbers).exclude?(k) }
+    end
+
+    private
+
+    def accurate_title
+      @taxonomy.root.seo_title.presence || @taxonomy.root.name
+    end
+  end
+end

data/app/controllers/spree/taxons_controller.rb

@@ -0,0 +1,46 @@
+module Spree
+  class TaxonsController < Spree::StoreController
+    include Spree::StorefrontHelper
+    helper 'spree/products'
+
+    before_action :load_taxon
+    after_action :track_show, only: :show
+
+    def show
+      redirect_if_legacy_path unless turbo_frame_request? || turbo_stream_request?
+
+      @current_page = current_theme.pages.find_by(type: 'Spree::Pages::Taxon')
+    end
+
+    private
+
+    def accurate_title
+      load_taxon unless @taxon
+      @taxon.seo_title
+    end
+
+    def load_taxon
+      @taxon ||= find_with_fallback_default_locale { current_store.taxons.friendly.find(params[:id]) }
+    end
+
+    def track_show
+      return if turbo_frame_request? || turbo_stream_request?
+
+      track_event('product_list_viewed', { taxon: @taxon })
+    end
+
+    def redirect_if_legacy_path
+      # If an old id or a numeric id was used to find the record,
+      # we should do a 301 redirect that uses the current friendly id.
+      if params[:id] != @taxon.friendly_id
+        params[:id] = @taxon.friendly_id
+        params.permit!
+        redirect_to url_for(params), status: :moved_permanently
+      end
+    end
+
+    def default_products_sort
+      @taxon.sort_order
+    end
+  end
+end

data/app/controllers/spree/wishlists_controller.rb

@@ -0,0 +1,19 @@
+module Spree
+  class WishlistsController < StoreController
+    def show
+      if params[:id].present? && params[:token].present?
+        @wishlist = current_store.wishlists.find_by!(id: params[:id], token: params[:token])
+      elsif try_spree_current_user
+        # https://github.com/spree/spree/blob/9475c6633b762669ee0c8f1f8a4d73e1c221a94e/core/app/models/concerns/spree/user_methods.rb#L71
+        @wishlist = try_spree_current_user.default_wishlist_for_store(current_store)
+      else
+        return require_user
+      end
+
+      @wished_items = @wishlist.wished_items.includes(
+        product: [:prices_including_master, :variants, :master, :taggings],
+        variant: [:images, :product, { option_values: :option_type }]
+      )
+    end
+  end
+end

data/app/finders/spree/storefront/variant_finder.rb

@@ -0,0 +1,80 @@
+module Spree
+  module Storefront
+    class VariantFinder
+      def initialize(product:, current_currency:, variant_id: nil, options_hash: {})
+        @product = product
+        @variant_id = variant_id
+        @current_currency = current_currency
+        @options_hash = options_hash
+      end
+
+      def find
+        try_variant_from_options
+        return [@selected_variant, @variant_from_options] if @selected_variant.present?
+
+        try_any_variant
+        [@selected_variant, @variant_from_options]
+      end
+
+      private
+
+      attr_reader :current_currency, :options_hash, :variant_id
+
+      def try_variant_from_options
+        return unless options_hash.present?
+        return unless (@product.option_type_ids.map(&:to_s) - options_hash.keys).empty?
+
+        @product.variants.each do |variant|
+          options_matched = options_hash.all? do |option_type_id, name|
+            variant.option_values.any? { |ov| ov.option_type_id.to_s == option_type_id && ov.name.downcase.strip == name.downcase.strip }
+          end
+
+          if options_matched && variant.purchasable? && variant.price_in(current_currency).amount.present?
+            @selected_variant = variant
+            @variant_from_options = variant
+            break
+          elsif options_matched
+            @variant_from_options = variant
+            break
+          end
+        end
+      end
+
+      def try_any_variant
+        if @product.has_variants?
+          if options_hash.present? # if selected combination is not purchasable nor active
+            @selected_variant = nil
+          elsif variant_id.present?
+            variant = @product.variants.find(variant_id)
+            @variant_from_options = variant
+            @selected_variant = variant
+          elsif product_option_types.size == 1 && product_option_types.first.color?
+            @selected_variant = @variant_from_options = @product.variants.find { |v| v.purchasable? && v.price_in(current_currency).amount.present? }
+          elsif @product.variants.size == 1 || product_has_only_one_secondary_option_type_value?
+            @variant_from_options = @product.variants.first
+            @selected_variant = @variant_from_options
+          end
+        elsif @product.master.purchasable? && @product.master.price_in(current_currency).amount.present?
+          @selected_variant = @variant_from_options = @product.master
+        else
+          @selected_variant = nil
+          @variant_from_options = @product.master
+        end
+      end
+
+      def product_has_only_one_secondary_option_type_value?
+        return false unless product_option_types.size == 2
+        return false unless product_option_types.first.color?
+
+        @product.
+          option_values.
+          select { |ov| ov.option_type_id == product_option_types.last.id }.
+          uniq(&:id).size == 1
+      end
+
+      def product_option_types
+        @product_option_types ||= @product.option_types.to_a
+      end
+    end
+  end
+end

data/app/helpers/spree/analytics_helper.rb

@@ -0,0 +1,28 @@
+module Spree
+  module AnalyticsHelper
+    def analytics_event_handlers
+      @analytics_event_handlers ||= Spree::Analytics.event_handlers.map do |handler|
+        handler.new(user: try_spree_current_user, session: session, request: request)
+      end
+    end
+
+    def track_event(event_name, record)
+      return if current_theme_preview.present?
+      return if unsupported_event?(event_name)
+
+      analytics_event_handlers.each do |handler|
+        handler.handle_event(event_name, record)
+      end
+    rescue => e
+      Rails.error.report(
+        e,
+        context: { event_name: event_name, record_id: record&.id, record_type: record&.class&.name },
+        source: 'spree.storefront'
+      )
+    end
+
+    def unsupported_event?(event_name)
+      !Spree::Analytics.events.key?(event_name.to_sym)
+    end
+  end
+end

data/app/helpers/spree/cart_helper.rb

@@ -0,0 +1,48 @@
+module Spree
+  module CartHelper
+    def quantity_field_options(opts = {})
+      opts[:min]   ||= 1
+      opts[:max]   ||= maximum_quantity
+
+      {
+        min: opts[:min], max: opts[:max],
+        class: opts[:class],
+        data: { 'quantity-picker-target': 'quantity' },
+        aria: { label: Spree.t(:quantity) }
+      }
+    end
+
+    def quantity_modifier_button_tag(text = '+', opts = {})
+      opts[:action] ||= 'increase'
+      opts[:type]   ||= 'button'
+
+      button_tag(
+        text,
+        type: opts[:type],
+        class: opts[:class],
+        data: {
+          'quantity-picker-target': opts[:action],
+          action: "click->quantity-picker##{opts[:action]} click->cart#disableCart"
+        }
+      )
+    end
+
+    def color_options_style_for_line_items(line_items)
+      @color_options_style_for_line_items = begin
+        colors = line_items.map(&:variant).map do |v|
+          color_option_values = v.option_values.find_all do |ov|
+            ov.option_type.color?
+          end
+
+          color_option_values.map do |ov|
+            { name: ov.name, filter_name: ov.name }
+          end
+        end
+
+        colors = colors.flatten.uniq { |color| [color[:name], color[:filter_name]] }
+
+        Spree::ColorsPreviewStylesPresenter.new(colors).to_s
+      end
+    end
+  end
+end

data/app/helpers/spree/checkout_analytics_helper.rb

@@ -0,0 +1,77 @@
+module Spree
+  module CheckoutAnalyticsHelper
+    def coupon_tracking_params
+      {
+        order: @order,
+        coupon_code: params[:coupon_code],
+        coupon_handler: @result
+      }
+    end
+
+    def clean_analytics_session
+      session.delete(:checkout_started)
+      session.delete(:checkout_step_viewed)
+      session.delete(:checkout_step_completed)
+    end
+
+    def clear_checkout_completed_session
+      session.delete(:checkout_completed)
+    end
+
+    def order_tracking_params
+      tracking_params = {
+        last_ip_address: request.remote_ip,
+      }
+
+      tracking_params[:ahoy_visit_id] = current_visit.id if @order.respond_to?(:ahoy_visit) && defined?(current_visit) && current_visit&.id
+      tracking_params
+    end
+
+    def track_checkout_started
+      # server-side tracking
+      track_event('checkout_started', { order: @order })
+
+      # client-side tracking
+      session[:checkout_started] = true
+    end
+
+    def track_checkout_entered_email
+      return unless @order.email.present?
+      return unless params.dig(:order, :email).present?
+
+      track_event('checkout_email_entered', { order: @order, email: @order.email })
+    end
+
+    def track_payment_info_entered
+      return unless @order.payment_method.present?
+      return unless params.dig(:order, :payments_attributes).present?
+
+      track_event('payment_info_entered', { order: @order })
+    end
+
+    def track_checkout_step_viewed
+      # server-side tracking
+      track_event('checkout_step_viewed', { order: @order, step: params[:state] || @order.state })
+
+      # client-side tracking
+      trackable_checkout_steps = @order.checkout_steps[0..2]
+      session[:checkout_step_viewed] = true if trackable_checkout_steps.include? @order.state
+    end
+
+    def track_checkout_step_completed
+      # server-side tracking
+      track_event('checkout_step_completed', { order: @order, step: @previous_state })
+
+      # client-side tracking
+      session[:checkout_step_completed] = @previous_state # for 3rd party frontend tracking
+    end
+
+    def track_checkout_completed
+      # server-side tracking
+      track_event('checkout_completed', { order: @order })
+
+      # client-side tracking
+      session[:checkout_completed] = true
+    end
+  end
+end

data/app/helpers/spree/checkout_helper.rb

@@ -0,0 +1,58 @@
+module Spree
+  module CheckoutHelper
+    def checkout_progress(numbers: false)
+      states = (@order.checkout_steps - ['complete']).unshift('cart')
+      states -= ['delivery'] if @order.digital?
+
+      items = states.each_with_index.map do |state, i|
+        text = Spree.t("order_state.#{state}").titleize
+        text.prepend("#{i.succ}. ") if numbers
+
+        css_classes = ['breadcrumb-item']
+
+        if @order.passed_checkout_step?(state)
+          link_content = text
+          link_url = if state == 'cart'
+                       spree.cart_url(host: current_store.url_or_custom_domain, order_token: @order.token)
+                     else
+                       spree.checkout_state_path(@order.token, state)
+                     end
+
+          text = link_to(link_content, link_url)
+          css_classes << 'text-primary'
+          content_tag('li', text, class: css_classes.join(' '))
+        else
+          content_tag('li', text, class: "breadcrumb-item #{state == @order.state ? 'font-bold' : 'text-text'}")
+        end
+      end
+      content_tag('ol', raw(items.join("\n")), class: 'breadcrumb flex items-center py-6 gap-2', id: "checkout-step-#{@order.state}")
+    end
+
+    def checkout_available_payment_methods
+      @checkout_available_payment_methods ||= @order.available_payment_methods.reject(&:store_credit?)
+    end
+
+    def checkout_started?
+      @order.state == 'address' && @order.state_was == 'cart'
+    end
+
+    def already_have_an_account?
+      @already_have_an_account ||= @order.email.present? && Spree.user_class.exists?(email: @order.email.downcase)
+    end
+
+    def checkout_payment_sources(payment_method = nil)
+      return [] unless try_spree_current_user.respond_to?(:payment_sources)
+
+      payment_method.present? ? try_spree_current_user.payment_sources.where(payment_method: payment_method) : try_spree_current_user.payment_sources
+    end
+
+    def quick_checkout_enabled?(order)
+      order.payment_required? && order.shipments.count <= 1 &&
+        (order.digital? || !order.some_digital?) # Either fully digital or not digital at all
+    end
+
+    def can_use_store_credit_on_checkout?(order)
+      order.could_use_store_credit? && (!order.respond_to?(:gift_card) || !order.gift_card.present?)
+    end
+  end
+end