spree_frontend 3.1.0 → 4.7.0

data/app/controllers/spree/content_controller.rb

@@ -1,23 +1,16 @@
 module Spree
   class ContentController < Spree::StoreController
     # Don't serve local files or static assets
-    before_action { render_404 if params[:path] =~ /(\.|\\)/ }
-    after_action :fire_visited_path, only: :show
+    after_action :fire_visited_path, except: :cvv
 
-    rescue_from ActionView::MissingTemplate, :with => :render_404
-
-    respond_to :html
-
-    def show
-      render :action => params[:path]
-    end
+    def test; end
 
     def cvv
-      render :layout => false
+      render layout: false
     end
 
     def fire_visited_path
-      Spree::PromotionHandler::Page.new(current_order, params[:path]).activate
+      Spree::PromotionHandler::Page.new(current_order, params[:action]).activate
     end
   end
 end

data/app/controllers/spree/currency_controller.rb

@@ -0,0 +1,17 @@
+module Spree
+  class CurrencyController < StoreController
+    def set
+      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
+
+      respond_to do |format|
+        format.html { redirect_back fallback_location: spree.root_path(currency: new_currency) }
+        format.json { head :ok }
+      end
+    end
+  end
+end

data/app/controllers/spree/errors_controller.rb

@@ -0,0 +1,11 @@
+module Spree
+  class ErrorsController < StoreController
+    def forbidden
+      render status: 403
+    end
+
+    def unauthorized
+      render status: 401
+    end
+  end
+end

data/app/controllers/spree/home_controller.rb

@@ -1,12 +1,46 @@
 module Spree
   class HomeController < Spree::StoreController
-    helper 'spree/products'
+    include Spree::CacheHelper
+
+    before_action :load_homepage, only: [:index]
+
     respond_to :html
 
     def index
-      @searcher = build_searcher(params.merge(include_images: true))
-      @products = @searcher.retrieve_products.includes(:possible_promotions)
-      @taxonomies = Spree::Taxonomy.includes(root: :children)
+      if @cms_home_page&.visible?
+        @homepage = @cms_home_page
+      elsif try_spree_current_user&.admin?
+        @homepage = @cms_home_page
+        @edit_mode = true
+      end
+
+      if http_cache_enabled?
+        fresh_when etag: store_etag, last_modified: last_modified_index, public: true
+      end
+    end
+
+    private
+
+    def etag_index
+      [
+        store_etag,
+        last_modified_index,
+      ]
+    end
+
+    def last_modified_index
+      page_last_modified = @cms_home_page&.maximum(:updated_at)&.utc if @cms_home_page.respond_to?(:maximum)
+      current_store_last_modified = current_store.updated_at.utc
+
+      [page_last_modified, current_store_last_modified].compact.max
+    end
+
+    def accurate_title
+      @cms_home_page&.seo_title || super
+    end
+
+    def load_homepage
+      @cms_home_page = current_store.homepage(I18n.locale)
     end
   end
 end

data/app/controllers/spree/locale_controller.rb

@@ -1,16 +1,43 @@
 module Spree
   class LocaleController < Spree::StoreController
+    REDIRECT_TO_ROOT = /\/(pages)\//.freeze
+
+    def index
+      render :index, layout: false
+    end
+
     def set
-      if request.referer && request.referer.starts_with?('http://' + request.host)
-        session['user_return_to'] = request.referer
+      new_locale = (params[:switch_to_locale] || params[:locale]).to_s
+
+      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
+
+        if should_build_new_url?
+          redirect_to BuildLocalizedRedirectUrl.call(
+            url: request.env['HTTP_REFERER'],
+            locale: new_locale,
+            default_locale: current_store.default_locale
+          ).value
+        else
+          redirect_to root_path(locale: new_locale)
+        end
+      else
+        redirect_to root_path
       end
-      if params[:locale] && I18n.available_locales.map(&:to_s).include?(params[:locale])
-        session[:locale] = I18n.locale = params[:locale]
-        flash.notice = Spree.t(:locale_changed)
+    end
+
+    private
+
+    def should_build_new_url?
+      return false if request.env['HTTP_REFERER'].blank?
+      if request.env['HTTP_REFERER'].match(REDIRECT_TO_ROOT)
+        false
       else
-        flash[:error] = Spree.t(:locale_not_changed)
+        request.env['HTTP_REFERER'] != request.env['REQUEST_URI']
       end
-      redirect_back_or_default(spree.root_path)
     end
   end
 end

data/app/controllers/spree/orders_controller.rb

@@ -1,113 +1,93 @@
 module Spree
   class OrdersController < Spree::StoreController
+    before_action :set_current_order
     before_action :check_authorization
-    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
-    helper 'spree/products', 'spree/orders'
 
-    respond_to :html
+    helper 'spree/products', 'spree/orders'
 
     before_action :assign_order_with_lock, only: :update
-    skip_before_action :verify_authenticity_token, only: [:populate]
 
     def show
-      @order = Order.includes(line_items: [variant: [:option_values, :images, :product]], bill_address: :state, ship_address: :state).find_by_number!(params[:id])
+      @order = current_store.orders.includes(line_items: [variant: [:option_values, :images, :product]], bill_address: :state, ship_address: :state).find_by!(number: params[:id])
     end
 
     def update
-      if @order.contents.update_cart(order_params)
+      @variant = curret_store.variants.find(params[:variant_id]) if params[:variant_id]
+      if Cart::Update.call(order: @order, params: order_params).success?
         respond_with(@order) do |format|
           format.html do
-            if params.has_key?(:checkout)
+            if params.key?(:checkout)
               @order.next if @order.cart?
-              redirect_to checkout_state_path(@order.checkout_steps.first)
+              redirect_to spree.checkout_state_path(@order.checkout_steps.first)
             else
-              redirect_to cart_path
+              redirect_to spree.cart_path
             end
           end
         end
       else
-        respond_with(@order)
+        respond_with(@order, status: :unprocessable_entity)
       end
     end
 
     # Shows the current incomplete order from the session
     def edit
-      @order = current_order || Order.incomplete.
-                                  includes(line_items: [variant: [:images, :option_values, :product]]).
-                                  find_or_initialize_by(guest_token: cookies.signed[:guest_token])
+      @order = current_order || current_store.orders.incomplete.
+               includes(line_items: [variant: [:images, :product, option_values: :option_type]]).
+               find_or_initialize_by(token: cookies.signed[:token])
       associate_user
     end
 
-    # Adds a new item to the order (creating a new order if none already exists)
-    def populate
-      order    = current_order(create_order_if_necessary: true)
-      variant  = Spree::Variant.find(params[:variant_id])
-      quantity = params[:quantity].to_i
-      options  = params[:options] || {}
-
-      # 2,147,483,647 is crazy. See issue #2695.
-      if quantity.between?(1, 2_147_483_647)
-        begin
-          order.contents.add(variant, quantity, options)
-        rescue ActiveRecord::RecordInvalid => e
-          error = e.record.errors.full_messages.join(", ")
-        end
-      else
-        error = Spree.t(:please_enter_reasonable_quantity)
-      end
-
-      if error
-        flash[:error] = error
-        redirect_back_or_default(spree.root_path)
-      else
-        respond_with(order) do |format|
-          format.html { redirect_to cart_path }
-        end
-      end
-    end
-
     def empty
-      if @order = current_order
-        @order.empty!
-      end
+      cart_empty_service.call(order: current_order)
 
       redirect_to spree.cart_path
     end
 
+    private
+
     def accurate_title
-      if @order && @order.completed?
-        Spree.t(:order_number, :number => @order.number)
+      if @order&.completed?
+        Spree.t(:order_number, number: @order.number)
       else
         Spree.t(:shopping_cart)
       end
     end
 
     def check_authorization
-      order = Spree::Order.find_by_number(params[:id]) || current_order
+      order = current_store.orders.find_by(number: params[:id]) if params[:id].present?
+      order ||= current_order
 
-      if order
-        authorize! :edit, order, cookies.signed[:guest_token]
+      if order && action_name.to_sym == :show
+        authorize! :show, order, cookies.signed[:token]
+      elsif order
+        authorize! :edit, order, cookies.signed[:token]
       else
         authorize! :create, Spree::Order
       end
     end
 
-    private
-
-      def order_params
-        if params[:order]
-          params[:order].permit(*permitted_order_attributes)
-        else
-          {}
-        end
+    def order_params
+      if params[:order]
+        params[:order].permit(*permitted_order_attributes)
+      else
+        {}
       end
+    end
 
-      def assign_order_with_lock
-        @order = current_order(lock: true)
-        unless @order
-          flash[:error] = Spree.t(:order_not_found)
-          redirect_to root_path and return
-        end
+    def assign_order_with_lock
+      @order = current_order(lock: true)
+      unless @order
+        flash[:error] = Spree.t(:order_not_found)
+        redirect_to root_path and return
       end
+    end
+
+    def cart_add_item_service
+      Spree::Dependencies.cart_add_item_service.constantize
+    end
+
+    def cart_empty_service
+      Spree::Dependencies.cart_empty_service.constantize
+    end
   end
 end

data/app/controllers/spree/products_controller.rb

@@ -1,59 +1,127 @@
 module Spree
   class ProductsController < Spree::StoreController
-    before_action :load_product, only: :show
-    before_action :load_taxon, only: :index
+    include Spree::ProductsHelper
+    include Spree::FrontendHelper
+    include Spree::CacheHelper
 
-    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
-    helper 'spree/taxons'
+    before_action :load_product, only: [:show, :related]
+    before_action :load_taxon, only: :index
 
-    respond_to :html
+    before_action :can_show_product?, only: :show
 
     def index
-      @searcher = build_searcher(params.merge(include_images: true))
-      @products = @searcher.retrieve_products.includes(:possible_promotions)
-      @taxonomies = Spree::Taxonomy.includes(root: :children)
+      @searcher = build_searcher(params.merge(include_images: true, current_store: current_store))
+      @products = @searcher.retrieve_products
+
+      if http_cache_enabled?
+        fresh_when etag: etag_index, last_modified: last_modified_index, public: true
+      end
     end
 
     def show
-      @variants = @product.variants_including_master.
-                           spree_base_scopes.
-                           active(current_currency).
-                           includes([:option_values, :images])
-      @product_properties = @product.product_properties.includes(:property)
-      @taxon = params[:taxon_id].present? ? Spree::Taxon.find(params[:taxon_id]) : @product.taxons.first
       redirect_if_legacy_path
-    end
 
-    private
+      @taxon = params[:taxon_id].present? ? taxons_scope.find_by(id: params[:taxon_id]) : nil
+      @taxon = @product.taxons.first unless @taxon.present?
 
-      def accurate_title
-        if @product
-          @product.meta_title.blank? ? @product.name : @product.meta_title
-        else
-          super
-        end
+      if !http_cache_enabled? || stale?(etag: etag_show, last_modified: last_modified_show, public: true)
+        @product_summary = Spree::ProductSummaryPresenter.new(@product).call
+        @product_properties = @product.product_properties.includes(:property)
+        @product_price = @product.price_in(current_currency).amount
+        load_variants
+        @product_images = product_images(@product, @variants)
       end
+    end
 
-      def load_product
-        if try_spree_current_user.try(:has_spree_role?, "admin")
-          @products = Product.with_deleted
-        else
-          @products = Product.active(current_currency)
-        end
-        @product = @products.includes(:variants_including_master).friendly.find(params[:id])
+    def related
+      if product_relation_types.any?
+        render template: 'spree/products/related', layout: false
+      else
+        head :no_content
       end
+    end
 
-      def load_taxon
-        @taxon = Spree::Taxon.find(params[:taxon]) if params[:taxon].present?
+    private
+
+    def accurate_title
+      if @product
+        @product.meta_title.blank? ? @product.name : @product.meta_title
+      else
+        super
       end
+    end
+
+    def load_product
+      @product = find_with_fallback_default_locale { current_store.products.for_user(try_spree_current_user).friendly.find(params[:id]) }
+    end
+
+    def load_taxon
+      @taxon = taxons_scope.find(params[:taxon]) if params[:taxon].present?
+    end
+
+    def can_show_product?
+      raise ActiveRecord::RecordNotFound if @product.stores.exclude?(current_store)
+    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.merge!(id: @product.friendly_id)
-          return redirect_to url_for(params), status: :moved_permanently
-        end
+    def load_variants
+      @variants = @product.
+                  variants_including_master.
+                  spree_base_scopes.
+                  active(current_currency).
+                  includes(
+                    :default_price,
+                    option_values: [:option_value_variants],
+                    images: { attachment_attachment: :blob }
+                  )
+    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 etag_index
+      [
+        store_etag,
+        last_modified_index,
+        available_option_types_cache_key,
+        filtering_params_cache_key
+      ]
+    end
+
+    def etag_show
+      [
+        store_etag,
+        @product,
+        @taxon,
+        @product.possible_promotion_ids,
+        @product.possible_promotions.maximum(:updated_at),
+      ]
+    end
+
+    alias product_etag etag_show
+
+    def last_modified_index
+      products_last_modified      = @products.maximum(:updated_at)&.utc if @products.respond_to?(:maximum)
+      current_store_last_modified = current_store.updated_at.utc
+
+      [products_last_modified, current_store_last_modified].compact.max
+    end
+
+    def last_modified_show
+      product_last_modified       = @product.updated_at.utc
+      current_store_last_modified = current_store.updated_at.utc
+
+      [product_last_modified, current_store_last_modified].compact.max
+    end
+
+    def taxons_scope
+      current_store.taxons
+    end
   end
 end

data/app/controllers/spree/store_controller.rb

@@ -1,44 +1,119 @@
 module Spree
-  class StoreController < Spree::BaseController
+  class StoreController < ApplicationController
+    include Spree::Core::ControllerHelpers::Auth
+    include Spree::Core::ControllerHelpers::Search
+    include Spree::Core::ControllerHelpers::Store
+    include Spree::Core::ControllerHelpers::StrongParameters
+    include Spree::Core::ControllerHelpers::Locale
+    include Spree::Core::ControllerHelpers::Currency
     include Spree::Core::ControllerHelpers::Order
+    include Spree::LocaleUrls
 
-    skip_before_action :set_current_order, only: :cart_link
+    respond_to :html
 
-    def forbidden
-      render 'spree/shared/forbidden', layout: Spree::Config[:layout], status: 403
-    end
+    layout :get_layout
+
+    helper 'spree/base'
+    helper 'spree/locale'
+    helper 'spree/currency'
+
+    helper_method :title
+    helper_method :title=
+    helper_method :accurate_title
 
-    def unauthorized
-      render 'spree/shared/unauthorized', layout: Spree::Config[:layout], status: 401
+    skip_before_action :verify_authenticity_token, only: :ensure_cart, raise: false
+
+    before_action :redirect_to_default_locale
+
+    def account_link
+      render partial: 'spree/shared/link_to_account'
+      fresh_when(etag: [try_spree_current_user, I18n.locale])
     end
 
     def cart_link
       render partial: 'spree/shared/link_to_cart'
-      fresh_when(simple_current_order)
+      fresh_when(etag: [simple_current_order, I18n.locale])
     end
 
-    protected
+    def api_tokens
+      render json: {
+        order_token: simple_current_order&.token,
+        oauth_token: current_oauth_token&.token
+      }
+    end
+
+    def ensure_cart
+      render json: current_order(create_order_if_necessary: true) # force creation of order if doesn't exists
+    end
 
-    # This method is placed here so that the CheckoutController
-    # and OrdersController can both reference it (or any other controller
-    # which needs it)
-    def apply_coupon_code
-      if params[:order] && params[:order][:coupon_code]
-        @order.coupon_code = params[:order][:coupon_code]
+    protected
 
-        handler = PromotionHandler::Coupon.new(@order).apply
+    # can be used in views as well as controllers.
+    # e.g. <% self.title = 'This is a custom title for this view' %>
+    attr_writer :title
 
-        if handler.error.present?
-          flash.now[:error] = handler.error
-          respond_with(@order) { |format| format.html { render :edit } } and return
-        elsif handler.success
-          flash[:success] = handler.success
+    def title
+      title_string = @title.present? ? @title : accurate_title
+      if title_string.present?
+        if Spree::Frontend::Config[:always_put_site_name_in_title] && !title_string.include?(default_title)
+          [title_string, default_title].join(" #{Spree::Frontend::Config[:title_site_name_separator]} ")
+        else
+          title_string
         end
+      else
+        default_title
       end
     end
 
+    def default_title
+      current_store.name
+    end
+
+    # this is a hook for subclasses to provide title
+    def accurate_title
+      current_store.seo_title
+    end
+
     def config_locale
       Spree::Frontend::Config[:locale]
     end
+
+    # Returns which layout to render.
+    #
+    # You can set the layout you want to render inside your Spree configuration with the +:layout+ option.
+    #
+    # Default layout is: +app/views/spree/layouts/spree_application+
+    #
+    def get_layout
+      layout ||= Spree::Frontend::Config[:layout]
+    end
+
+    def store_etag
+      [
+        current_store,
+        current_currency,
+        I18n.locale,
+        try_spree_current_user.present?,
+        try_spree_current_user.try(:has_spree_role?, 'admin')
+      ].compact
+    end
+
+    def store_last_modified
+      (current_store.updated_at || Time.current).utc
+    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
   end
 end