spree_storefront 5.0.0.rc1

data/app/controllers/spree/orders_controller.rb

@@ -0,0 +1,104 @@
+# overwrote this controller to drop empty and show actions
+# show action has it's own controller order_status
+# empty is not needed anymore
+module Spree
+  class OrdersController < StoreController
+    include Spree::Core::ControllerHelpers::Order
+    include CartMethods
+
+    helper 'spree/products'
+
+    before_action :assign_order_with_lock, only: :update
+
+    # GET /orders/:id
+    def show
+      @order = complete_order_finder.new(number: params[:id], token: params[:token], store: current_store).execute.first
+
+      raise ActiveRecord::RecordNotFound if @order.blank? || !authorize_access
+
+      @shipments = @order.shipments.includes(:stock_location, :address, selected_shipping_rate: :shipping_method, inventory_units: :line_item)
+    end
+
+    # PUT /cart
+    def update
+      @variant = current_store.variants.find(params[:variant_id]) if params[:variant_id]
+      @result = cart_update_service.call(order: @order, params: order_params)
+
+      if @result.success?
+        if params.key?(:checkout)
+          @order.next if @order.cart?
+          redirect_to spree.checkout_state_path(@order.token, @order.checkout_steps.first)
+        else
+          redirect_to spree.cart_path
+        end
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # GET /cart
+    def edit
+      flash.keep if request.format.turbo_stream?
+      @order = current_order || find_order_by_cookie
+      associate_user
+
+      remove_out_of_stock_items
+      load_line_items
+    end
+
+    private
+
+    def authorize_access
+      return true if @order.user_id.nil?
+
+      @order.user == try_spree_current_user
+    end
+
+    def find_order_by_cookie
+      if order_token.present?
+        current_store.orders.incomplete.not_canceled.
+          includes(line_items: [variant: [:images, :product, { option_values: :option_type }]]).
+          find_by(token: order_token)
+      else
+        current_store.orders.incomplete.new
+      end
+    end
+
+    def accurate_title
+      if action_name == 'edit' || action_name == 'update'
+        Spree.t(:shopping_cart)
+      else
+        Spree.t(:order_number, number: @order&.number)
+      end
+    end
+
+    def order_params
+      if params[:order]
+        params[:order].permit(*permitted_order_attributes)
+      else
+        {}
+      end
+    end
+
+    def cart_remove_out_of_stock_items_service
+      Spree::Dependencies.cart_remove_out_of_stock_items_service.constantize
+    end
+
+    def cart_update_service
+      Spree::Dependencies.cart_update_service.constantize
+    end
+
+    def complete_order_finder
+      Spree::Dependencies.completed_order_finder.constantize
+    end
+
+    def remove_out_of_stock_items
+      return unless @order&.persisted?
+
+      ActiveRecord::Base.connected_to(role: :writing) do
+        @order, messages = cart_remove_out_of_stock_items_service.call(order: @order).value
+        flash[:error] = messages.to_sentence if messages.any?
+      end
+    end
+  end
+end

data/app/controllers/spree/page_sections_controller.rb

@@ -0,0 +1,17 @@
+module Spree
+  class PageSectionsController < StoreController
+    helper_method :section_variables
+
+    def show
+      @section = Spree::PageSection.with_deleted.find(params[:id])
+    end
+
+    def section_variables
+      @section_variables ||= begin
+        variables = {}
+
+        variables
+      end
+    end
+  end
+end

data/app/controllers/spree/pages_controller.rb

@@ -0,0 +1,13 @@
+module Spree
+  class PagesController < StoreController
+    def show
+      @current_page = @page = current_store.pages.custom.friendly.find(params[:id])
+    end
+
+    private
+
+    def title
+      @title ||= @page.meta_title.presence || @page.name
+    end
+  end
+end

data/app/controllers/spree/password_controller.rb

@@ -0,0 +1,21 @@
+module Spree
+  class PasswordController < StoreController
+    layout 'spree/password'
+
+    skip_before_action :redirect_to_password
+
+    def show
+      @current_page = current_theme.pages.find_by(type: 'Spree::Pages::Password')
+    end
+
+    def check
+      if params[:password] == current_store.storefront_password
+        session[:password_valid] = true
+        redirect_to root_path
+      else
+        flash[:error] = 'Incorrect password. Please try again.'
+        redirect_to password_path
+      end
+    end
+  end
+end

data/app/controllers/spree/policies_controller.rb

@@ -0,0 +1,17 @@
+module Spree
+  class PoliciesController < StoreController
+    def show
+      if params[:id].in?(supported_policies)
+        @policy = current_store.send("customer_#{params[:id]}")
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    private
+
+    def supported_policies
+      %w[privacy_policy terms_of_service returns_policy shipping_policy]
+    end
+  end
+end

data/app/controllers/spree/posts_controller.rb

@@ -0,0 +1,76 @@
+module Spree
+  class PostsController < Spree::StoreController
+    before_action :load_category, if: -> { params[:category_id].present? }, only: :index
+    before_action :load_tag, if: -> { params[:tag].present? }, only: :index
+
+    after_action :track_show, only: :show
+
+    def index
+      @current_page = current_theme.pages.find_by!(type: 'Spree::Pages::PostList')
+
+      scope = current_store.posts.published
+      scope = scope.tagged_with(@tag.name) if @tag.present?
+      scope = scope.where(post_category_id: @category.id) if @category.present?
+
+      sorted_posts = scope.order(published_at: :desc)
+      @posts = sorted_posts.page(params[:page]).per(20)
+    end
+
+    def show
+      if params[:preview_id].present?
+        preview_post = current_store.posts.friendly.find(params[:id])
+        raise ActiveRecord::RecordNotFound if preview_post.id.to_s != params[:preview_id]
+
+        @post ||= preview_post
+      else
+        @post = current_store.posts.friendly.published.find(params[:id])
+      end
+
+      @current_page = current_theme.pages.find_by!(type: 'Spree::Pages::Post')
+    end
+
+    def related_products
+      @post = Spree::Post.friendly.find(params[:id])
+      current_page = current_theme.pages.find_by!(type: 'Spree::Pages::Post')
+      @section = current_page.sections.find_by!(id: params[:section_id], type: 'Spree::PageSections::RelatedProducts')
+    end
+
+    private
+
+    def accurate_title
+      if @post
+        @post.meta_title.presence || @post.title
+      elsif @category.present? && @tag.present?
+        "#{@category.title} / #{@tag.name.titleize}"
+      elsif @category.present?
+        @category.title
+      elsif @tag.present?
+        Spree.t(:all_posts_with_tag, tag: @tag.name.titleize)
+      else
+        Spree.t(:all_posts)
+      end
+    end
+
+    def load_category
+      @category = current_store.post_categories.friendly.find(params[:category_id])
+      @page_description = @category.description.to_plain_text
+    end
+
+    def load_tag
+      @tag = post_tags_scope.find_by!(name: params[:tag].strip)
+    end
+
+    def post_tags_scope
+      @post_tags_scope ||= ActsAsTaggableOn::Tag.
+                           joins(:taggings).
+                           where('taggings.taggable_type = ?', Spree::Post.to_s).
+                           for_context(:tags).for_tenant(current_store.id)
+    end
+
+    def track_show
+      return if turbo_frame_request? || turbo_stream_request?
+
+      track_event('post_viewed', { post_id: @post.id })
+    end
+  end
+end

data/app/controllers/spree/products_controller.rb

@@ -0,0 +1,99 @@
+module Spree
+  class ProductsController < Spree::StoreController
+    helper 'spree/products'
+
+    after_action :track_show, only: :show
+    after_action :track_index, only: :index
+
+    def index
+      @current_page = current_theme.pages.find_by(type: 'Spree::Pages::ShopAll')
+    end
+
+    def show
+      load_product
+      redirect_if_legacy_path
+
+      @current_page = current_theme.pages.product_details.first
+    end
+
+    def related
+      @current_page = current_theme.pages.product_details.first
+      section_scope = @current_page.sections.related_products
+      @section = section_scope.find_by(id: params[:section_id]) || section_scope.first
+      load_product
+      # An interesting thing is that since we're querying the translations table (in the multi_search),
+      # when using not default locale, our related products are different for different locales.
+      @products = current_store.products.active(current_currency).where.not(id: @product.id).
+                  multi_search(@product.name).includes(storefront_products_includes).
+                  limit(@section.preferred_max_products_to_show)
+    end
+
+    private
+
+    def accurate_title
+      load_product if action_name == 'show' # we need this for ahoy analytics
+
+      if @product
+        @product.meta_title.blank? ? @product.name : @product.meta_title
+      else
+        params[:q].present? ? Spree.t(:search_results_for, query: params[:q]) : Spree.t(:shop_all)
+      end
+    end
+
+    def load_product
+      if params[:preview_id].present?
+        possible_product = find_with_fallback_default_locale { current_store.products.friendly.find(params[:id]) }
+
+        raise ActiveRecord::RecordNotFound if possible_product.id.to_s != params[:preview_id].to_s
+
+        @product ||= possible_product
+      else
+        @product ||= find_with_fallback_default_locale { current_store.products.for_user(try_spree_current_user).friendly.find(params[:id]) }
+      end
+
+      options_hash = if params[:options].present?
+                       params[:options].split(',').to_h do |option|
+                         key, *value = option.split(':')
+                         [key, value.join(':')]
+                       end
+                     else
+                       {}
+                     end
+
+      variant_finder = Spree::Storefront::VariantFinder.new(
+        product: @product,
+        variant_id: params[:variant_id],
+        current_currency: current_currency,
+        options_hash: options_hash
+      )
+
+      @selected_variant, @variant_from_options =
+        Rails.cache.fetch([@product.cache_key_with_version, 'variant-finder', current_currency, params[:variant_id], options_hash].compact) do
+          variant_finder.find
+        end
+    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] != @product.friendly_id
+        params[:id] = @product.friendly_id
+        params.permit!
+        redirect_to url_for(params), status: :moved_permanently
+      end
+    end
+
+    def track_show
+      return if turbo_frame_request? || turbo_stream_request?
+      return if params[:options].present? # we don't want to track product views for variants
+
+      track_event('product_viewed', { product: @product })
+    end
+
+    def track_index
+      return if turbo_frame_request? || turbo_stream_request?
+
+      track_event('product_list_viewed', { taxon: @taxon })
+    end
+  end
+end

data/app/controllers/spree/search_controller.rb

@@ -0,0 +1,39 @@
+module Spree
+  class SearchController < StoreController
+    after_action :track, only: :show
+
+    helper_method :query
+
+    def show
+      @current_page = current_theme.pages.find_by(type: 'Spree::Pages::SearchResults')
+    end
+
+    def suggestions
+      @products = []
+      @taxons = []
+
+      if query.present? && query.length >= Spree::Storefront::Config.search_min_query_length
+        products_scope = current_store.products.active(current_currency).multi_search(query)
+        @products = products_scope.includes(storefront_products_includes)
+        @taxons = current_store.taxons.search_by_name(query)
+      end
+    end
+
+    private
+
+    def query
+      @query ||= params[:q].presence&.strip_html_tags&.strip
+    end
+
+    def track
+      return if turbo_frame_request? || turbo_stream_request?
+      return if query.blank?
+
+      track_event('product_searched', { query: query })
+    end
+
+    def default_products_sort
+      'manual'
+    end
+  end
+end

data/app/controllers/spree/seo_controller.rb

@@ -0,0 +1,25 @@
+module Spree
+  class SeoController < StoreController
+    include BaseHelper
+    include StorefrontHelper
+
+    def robots
+      render view: 'seo/robots', layout: false, content_type: 'text/plain', locals: { store: current_store }
+    end
+
+    def sitemap
+      unless current_store.prefers_index_in_search_engines?
+        head :not_found
+        return
+      end
+
+      respond_to do |format|
+        format.xml
+        format.gzip do
+          gz_xml = ActiveSupport::Gzip.compress(render_to_string(template: 'spree/seo/sitemap', formats: [:xml]))
+          send_data(gz_xml, filename: 'sitemap.xml.gz', type: 'application/x-gzip', disposition: 'inline')
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/settings_controller.rb

@@ -0,0 +1,68 @@
+module Spree
+  class SettingsController < Spree::StoreController
+    def show; end
+
+    def update
+      new_locale = (params[:switch_to_locale] || params[:locale]).to_s
+      new_currency = params[:switch_to_currency]&.upcase
+
+      if new_currency.present? && supported_currency?(new_currency)
+        current_order&.update(currency: new_currency)
+        session[:currency] = new_currency
+      end
+
+      if new_locale.present? && supported_locale?(new_locale)
+        if try_spree_current_user && try_spree_current_user.selected_locale != new_locale
+          try_spree_current_user.update!(selected_locale: new_locale)
+        end
+
+        locale_for_slug = new_locale
+        new_locale = nil if new_locale.to_s == current_store.default_locale.to_s
+
+        if request.referer.present?
+          uri = URI(request.referer)
+
+          previous_params = begin
+            Spree::Core::Engine.routes.recognize_path(uri.path)
+          rescue ActionController::RoutingError
+            Rails.application.routes.recognize_path(uri.path)
+          end
+
+          redirect_to spree.root_path(locale: new_locale) && return if previous_params.blank?
+
+          new_params = previous_params.clone.merge(locale: new_locale)
+
+          # We only care if the previous url was for a specific record, because we need to find it with the slug/permalink from the new locale
+          new_params[:id] = find_slug_in_current_locale(previous_params, locale_for_slug)
+
+          redirect_to new_params
+        else
+          redirect_to spree.root_path(locale: new_locale)
+        end
+      else
+        redirect_to spree.root_path
+      end
+    end
+
+    private
+
+    def find_slug_in_current_locale(params, new_locale)
+      if params[:id].present?
+        case params[:controller]
+        when 'spree/products'
+          old_product = find_with_fallback(params[:locale]) { current_store.products.friendly.find(params[:id]) }
+          old_product.slug(locale: new_locale) || old_product.slug(locale: current_store.default_locale)
+        when 'spree/taxons'
+          old_taxon = find_with_fallback(params[:locale]) { current_store.taxons.friendly.find(params[:id]) }
+          old_taxon.permalink(locale: new_locale) || old_taxon.permalink(locale: current_store.default_locale)
+        else
+          params[:id]
+        end
+      end
+    end
+
+    def find_with_fallback(locale, &block)
+      Mobility.with_locale(locale) { find_with_fallback_default_locale(&block) }
+    end
+  end
+end