workarea-storefront 3.4.12

data/app/controllers/workarea/storefront/email_signups_controller.rb

@@ -0,0 +1,19 @@
+module Workarea
+  class Storefront::EmailSignupsController < Storefront::ApplicationController
+    def show
+      @content = Storefront::EmailSignupsViewModel.new
+    end
+
+    def create
+      signup = Email.signup(params[:email])
+
+      if signup.try(:valid?)
+        flash[:success] = t('workarea.storefront.flash_messages.email_signed_up')
+      else
+        flash[:error] = t('workarea.storefront.flash_messages.email_signup_error')
+      end
+
+      redirect_back fallback_location: root_path
+    end
+  end
+end

data/app/controllers/workarea/storefront/errors_controller.rb

@@ -0,0 +1,58 @@
+module Workarea
+  module Storefront
+    class ErrorsController < Storefront::ApplicationController
+      def not_found
+        redirect_url = Navigation::Redirect.find_destination(
+          request.env['action_dispatch.original_path']
+        )
+
+        if redirect_url.present?
+          redirect_to redirect_url, status: :moved_permanently
+        else
+          render_error_page(404)
+        end
+      end
+
+      def internal
+        # This ensures any exception handling (e.g. Airbrake or Sentry) will see
+        # the error in their middleware, and then report on it.
+        request.env['rack.exception'] = request.env['action_dispatch.exception']
+        render_error_page(500)
+      end
+
+      def offline
+        content = Content.for('offline')
+        @content = ContentViewModel.wrap(content)
+
+        render('workarea/storefront/errors/show')
+      end
+
+      private
+
+      def render_error_page(error_status)
+        name = Rack::Utils::HTTP_STATUS_CODES[error_status].titleize
+
+        respond_to do |format|
+          format.all do
+            if !request.format.html?
+              head error_status
+            elsif content = Content.for(name)
+              @content = ContentViewModel.new(content)
+
+              render(
+                template: 'workarea/storefront/errors/show',
+                status: error_status
+              )
+            else
+              render(
+                file: "#{Rails.root}/public/#{error_status}.html",
+                layout: nil,
+                status: error_status
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/http_caching.rb

@@ -0,0 +1,33 @@
+module Workarea
+  module Storefront
+    module HttpCaching
+      extend ActiveSupport::Concern
+
+      included do
+        after_action :set_vary_headers
+        helper_method :http_caching?
+      end
+
+      def cache_page
+        unless current_user.try(:admin?)
+          expires_in Workarea.config.cache_expirations.http_cache, public: true if flash.blank?
+          request.session_options[:skip] = true
+          @http_caching = true
+        end
+      end
+
+      def http_caching?
+        !!@http_caching
+      end
+
+      private
+
+      def set_vary_headers
+        response.headers['X-Requested-With'] = request.headers['X-Requested-With'] || ''
+        response.headers['X-Flash-Messages'] ||= ''
+
+        response.headers['Vary'] = 'X-Requested-With, X-Flash-Messages'
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/menus_controller.rb

@@ -0,0 +1,25 @@
+module Workarea
+  module Storefront
+    class MenusController < Storefront::ApplicationController
+      before_action :cache_page
+
+      layout :navigation_layout
+
+      def index
+        models = Navigation::Menu.all.select(&:active?)
+        @menus = MenuViewModel.wrap(models, params)
+      end
+
+      def show
+        model = Navigation::Menu.find(params[:id])
+        @menu = MenuViewModel.wrap(model, params)
+      end
+
+      private
+
+      def navigation_layout
+        request.xhr? ? false : 'workarea/storefront/navigation'
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/order_lookup.rb

@@ -0,0 +1,20 @@
+module Workarea
+  module Storefront
+    module OrderLookup
+      extend ActiveSupport::Concern
+
+      def lookup_order
+        return @lookup_order if defined?(@lookup_order)
+
+        @lookup_order = if session[:lookup_order_id]
+                          Order.find(session[:lookup_order_id])
+                        end
+      end
+
+      def lookup_order=(order)
+        session[:lookup_order_id] = order.try(:id)
+        @lookup_order = order
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/orders_controller.rb

@@ -0,0 +1,29 @@
+module Workarea
+  class Storefront::OrdersController < Storefront::ApplicationController
+    def index
+      redirect_to users_orders_path if logged_in?
+    end
+
+    def lookup
+      @payment = Payment.lookup(params[:order_id], params[:postal_code])
+
+      if @payment
+        self.lookup_order = Order.find(@payment.id)
+        redirect_to order_path(lookup_order)
+      else
+        self.lookup_order = nil
+        flash[:error] = t('workarea.storefront.flash_messages.no_matching_order')
+        redirect_to check_orders_path
+      end
+    end
+
+    def show
+      if lookup_order.try(:id).to_s.downcase != params[:id].to_s.downcase
+        flash[:error] = t('workarea.storefront.flash_messages.no_matching_order')
+        redirect_to check_orders_path
+      end
+
+      @order = Storefront::OrderViewModel.wrap(lookup_order, view_model_options)
+    end
+  end
+end

data/app/controllers/workarea/storefront/pages_controller.rb

@@ -0,0 +1,23 @@
+module Workarea
+  class Storefront::PagesController < Storefront::ApplicationController
+    before_action :cache_page
+
+    def show
+      model = Content::Page.find_by(slug: params[:id])
+      raise InvalidDisplay unless model.active? || current_user.try(:admin?)
+      @page = Storefront::PageViewModel.new(model, view_model_options)
+    end
+
+    def home_page
+      @page = Storefront::ContentViewModel.new(
+        Content.for('home_page'),
+        view_model_options
+      )
+    end
+
+    def robots; end
+    def accessibility; end
+    def browser_config; end
+    def web_manifest; end
+  end
+end

data/app/controllers/workarea/storefront/products_controller.rb

@@ -0,0 +1,25 @@
+module Workarea
+  class Storefront::ProductsController < Storefront::ApplicationController
+    before_action :cache_page
+
+    def show
+      model = Catalog::Product.find_by(slug: params[:id])
+      raise InvalidDisplay unless model.active? || current_user.try(:admin?)
+
+      @product = Storefront::ProductViewModel.wrap(
+        model,
+        view_model_options
+      )
+    end
+
+    def details
+      model = Catalog::Product.find_by(slug: params[:id])
+      raise InvalidDisplay unless model.active? || current_user.try(:admin?)
+
+      @product = Storefront::ProductViewModel.wrap(
+        model,
+        view_model_options
+      )
+    end
+  end
+end

data/app/controllers/workarea/storefront/recent_views_controller.rb

@@ -0,0 +1,51 @@
+module Workarea
+  class Storefront::RecentViewsController < Storefront::ApplicationController
+    skip_before_action :verify_authenticity_token
+    before_action :block_robots
+
+    def show
+      if stale?(etag: user_activity, last_modified: user_activity.updated_at)
+        @recent_views = Storefront::UserActivityViewModel.new(user_activity)
+        render params[:view].in?(allowed_alt_views) ? params[:view] : :show
+      end
+    end
+
+    def update
+      if params[:product_id].present?
+        Recommendation::UserActivity.save_product(
+          current_user_activity_id,
+          params[:product_id]
+        )
+      end
+
+      if params[:category_id].present?
+        Recommendation::UserActivity.save_category(
+          current_user_activity_id,
+          params[:category_id]
+        )
+      end
+
+      if params[:search].present?
+        Recommendation::UserActivity.save_search(
+          current_user_activity_id,
+          params[:search]
+        )
+      end
+
+      head :ok
+    end
+
+    private
+
+    def allowed_alt_views
+      ['aside', 'narrow']
+    end
+
+    def block_robots
+      if Robots.is_robot?(request.user_agent)
+        head :forbidden
+        return false
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/recommendations_controller.rb

@@ -0,0 +1,11 @@
+module Workarea
+  class Storefront::RecommendationsController < Storefront::ApplicationController
+    def show
+      fresh_when(etag: user_activity, last_modified: user_activity.updated_at)
+      @recommendations = Storefront::PersonalizedRecommendationsViewModel.new(
+        user_activity,
+        view_model_options
+      )
+    end
+  end
+end

data/app/controllers/workarea/storefront/searches_controller.rb

@@ -0,0 +1,47 @@
+module Workarea
+  module Storefront
+    class SearchesController < Storefront::ApplicationController
+      before_action :cache_page
+
+      def index
+        render nothing: true and return if search_query.blank?
+        autocomplete_params = params.permit(:q)
+
+        search = Search::SearchSuggestions.new(autocomplete_params)
+
+        @results = search.results.map do |result|
+          SearchSuggestionViewModel.new(result).to_h
+        end
+      end
+
+      def show
+        if search_query.blank?
+          flash[:error] = t('workarea.storefront.flash_messages.no_search_query')
+          redirect_back fallback_location: root_path
+          return
+        end
+
+        response = Search::StorefrontSearch.new(params.to_unsafe_h).response
+        handle_search_response(response)
+      end
+
+      private
+
+      def search_query
+        QueryString.new(params[:q]).sanitized
+      end
+
+      def handle_search_response(response)
+        redirect_to response.redirect and return if response.redirect?
+
+        set_search(response)
+        status = response.template == 'no_results' ? :not_found : :ok
+        render response.template, status: status
+      end
+
+      def set_search(response)
+        @search = SearchViewModel.new(response, view_model_options)
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/sitemaps_controller.rb

@@ -0,0 +1,11 @@
+module Workarea
+  module Storefront
+    class SitemapsController < Storefront::ApplicationController
+      before_action :cache_page
+
+      def show
+        @sitemap = TaxonomySitemap.new(view_model_options)
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/style_guides_controller.rb

@@ -0,0 +1,6 @@
+module Workarea
+  class Storefront::StyleGuidesController < Storefront::ApplicationController
+    layout 'workarea/storefront/empty'
+    include StyleGuides
+  end
+end

data/app/controllers/workarea/storefront/user_activity.rb

@@ -0,0 +1,17 @@
+module Workarea
+  module Storefront
+    module UserActivity
+      def user_activity
+        return Recommendation::UserActivity.new if current_user_activity_id.blank?
+
+        @user_activity ||= Recommendation::UserActivity.find_or_initialize_by(
+          id: current_user_activity_id
+        )
+      end
+
+      def current_user_activity_id
+        current_user.try(:id).presence || session.id
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/users/accounts_controller.rb

@@ -0,0 +1,91 @@
+module Workarea
+  class Storefront::Users::AccountsController < Storefront::ApplicationController
+    before_action :require_login, only: [:show, :edit, :update]
+    before_action :require_logout, only: :create
+    before_action :find_recommendations, only: :show
+
+    def show
+      @user = Storefront::UserViewModel.new(current_user)
+    end
+
+    def edit
+      @user = Storefront::UserViewModel.new(current_user)
+    end
+
+    def create
+      @user = User.new(user_params)
+
+      if @user.save
+        login(@user)
+        Login.new(@user, current_order).perform
+
+        Storefront::AccountMailer.creation(@user.id.to_s).deliver_later
+        save_completed_order_details(@user) if completed_order.present?
+        Email.signup(@user.email) if params[:email_signup].present?
+
+        flash[:success] = t('workarea.storefront.flash_messages.account_created')
+        redirect_back_or users_account_path
+      else
+        flash[:error] = t('workarea.storefront.flash_messages.account_create_error')
+        render 'workarea/storefront/users/logins/new'
+      end
+    end
+
+    def update
+      if current_user.update_attributes(user_params)
+        update_email_signup
+        flash[:success] = t('workarea.storefront.flash_messages.account_updated')
+        redirect_to users_account_path
+      else
+        flash[:error] = current_user.errors.to_a.to_sentence
+        current_user.reload
+
+        @user = Storefront::UserViewModel.new(current_user)
+        find_recommendations
+        render :show
+      end
+    end
+
+    def update_email_signup
+      return unless params.key?(:email_signup)
+
+      if params[:email_signup].to_s =~ /true/
+        Email.signup(current_user.email)
+      else
+        Email.unsignup(current_user.email)
+      end
+    end
+
+    private
+
+    def find_recommendations
+      @recommendations = Storefront::PersonalizedRecommendationsViewModel.new(
+        user_activity,
+        view_model_options
+      )
+    end
+
+    def user_params
+      params.permit(
+        :email,
+        :password,
+        :first_name,
+        :last_name
+      )
+    end
+
+    def completed_order
+      return unless cookies.signed[:completed_order].present?
+      Order.find(cookies.signed[:completed_order])
+    end
+
+    def save_completed_order_details(user)
+      if user.email == completed_order.email
+        completed_order.update_attributes!(user_id: user.id)
+        SaveUserOrderDetails.new.perform(completed_order.id)
+      end
+
+      cookies.delete(:completed_order)
+    end
+  end
+end