solidus_starter_frontend 0.1.0

data/app/assets/stylesheets/spree/frontend/solidus_starter_frontend.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require spree/frontend/screen
+*/

data/app/assets/stylesheets/spree/frontend/variables/_colors.scss

@@ -0,0 +1,20 @@
+/*--------------------------------------*/
+/* Colors
+/*--------------------------------------*/
+
+$color_accent: #3C76f0;
+
+$color-background-alert: #fdd200;
+$color-background-dark: #24282f;
+$color-background-error: #e4361b;
+$color-background-light: #f2f2f2;
+$color-background-success: #1bc16d;
+
+$color-border: #ddd;
+$color-border-dark: #222;
+$color-border-medium: #d8d8d8;
+$color-border-light: #f2f2f2;
+
+$color-copy: #222;
+$color-copy-light: #777;
+$color-copy-bright: #fff;

data/app/controllers/concerns/solidus_starter_frontend/auth_views.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusStarterFrontend
+  module AuthViews
+    extend ActiveSupport::Concern
+    included do
+      before_action :configure_views
+    end
+
+    protected
+
+    def configure_views
+      prepend_view_path Engine.root.join('lib', 'views', 'auth')
+    end
+  end
+end

data/app/controllers/concerns/solidus_starter_frontend/taxonomies.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusStarterFrontend
+  module Taxonomies
+    extend ActiveSupport::Concern
+    included do
+      helper_method :taxonomies
+    end
+
+    protected
+
+    def taxonomies
+      @taxonomies ||= Spree::Taxonomy.includes(root: :children)
+    end
+  end
+end

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Spree
+  # This is somewhat contrary to standard REST convention since there is not
+  # actually a Checkout object. There's enough distinct logic specific to
+  # checkout which has nothing to do with updating an order that this approach
+  # is warranted.
+  class CheckoutController < Spree::StoreController
+    before_action :load_order
+    around_action :lock_order
+
+    before_action :ensure_order_is_not_skipping_states
+    before_action :ensure_order_not_completed
+    before_action :ensure_checkout_allowed
+    before_action :ensure_sufficient_stock_lines
+    before_action :ensure_valid_state
+
+    before_action :associate_user
+    before_action :check_authorization
+
+    before_action :setup_for_current_state, only: [:edit, :update]
+
+    helper 'spree/orders'
+
+    rescue_from Spree::Core::GatewayError, with: :rescue_from_spree_gateway_error
+    rescue_from Spree::Order::InsufficientStock, with: :insufficient_stock_error
+
+    # Updates the order and advances to the next state (when possible.)
+    def update
+      if update_order
+
+        assign_temp_address
+
+        unless transition_forward
+          redirect_on_failure
+          return
+        end
+
+        if @order.completed?
+          finalize_order
+        else
+          send_to_next_state
+        end
+
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def update_order
+      OrderUpdateAttributes.new(@order, update_params, request_env: request.headers.env).apply
+    end
+
+    def assign_temp_address
+      @order.temporary_address = !params[:save_user_address]
+    end
+
+    def redirect_on_failure
+      flash[:error] = @order.errors.full_messages.join("\n")
+      redirect_to(checkout_state_path(@order.state))
+    end
+
+    def transition_forward
+      if @order.can_complete?
+        @order.complete
+      else
+        @order.next
+      end
+    end
+
+    def finalize_order
+      @current_order = nil
+      set_successful_flash_notice
+      redirect_to completion_route
+    end
+
+    def set_successful_flash_notice
+      flash.notice = t('spree.order_processed_successfully')
+      flash['order_completed'] = true
+    end
+
+    def send_to_next_state
+      redirect_to checkout_state_path(@order.state)
+    end
+
+    def update_params
+      case params[:state].to_sym
+      when :address
+        massaged_params.require(:order).permit(
+          permitted_checkout_address_attributes
+        )
+      when :delivery
+        massaged_params.require(:order).permit(
+          permitted_checkout_delivery_attributes
+        )
+      when :payment
+        massaged_params.require(:order).permit(
+          permitted_checkout_payment_attributes
+        )
+      else
+        massaged_params.fetch(:order, {}).permit(
+          permitted_checkout_confirm_attributes
+        )
+      end
+    end
+
+    def massaged_params
+      massaged_params = params.deep_dup
+
+      move_payment_source_into_payments_attributes(massaged_params)
+      move_wallet_payment_source_id_into_payments_attributes(massaged_params)
+      set_payment_parameters_amount(massaged_params, @order)
+
+      massaged_params
+    end
+
+    def ensure_valid_state
+      unless skip_state_validation?
+        if (params[:state] && !@order.has_checkout_step?(params[:state])) ||
+           (!params[:state] && !@order.has_checkout_step?(@order.state))
+          @order.state = 'cart'
+          redirect_to checkout_state_path(@order.checkout_steps.first)
+        end
+      end
+
+      # Fix for https://github.com/spree/spree/issues/4117
+      # If confirmation of payment fails, redirect back to payment screen
+      if params[:state] == "confirm" && @order.payment_required? && @order.payments.valid.empty?
+        flash.keep
+        redirect_to checkout_state_path("payment")
+      end
+    end
+
+    # Should be overriden if you have areas of your checkout that don't match
+    # up to a step within checkout_steps, such as a registration step
+    def skip_state_validation?
+      false
+    end
+
+    def load_order
+      @order = current_order
+      redirect_to(spree.cart_path) && return unless @order
+    end
+
+    # Allow the customer to only go back or stay on the current state
+    # when trying to change it via params[:state]. It's not allowed to
+    # jump forward and skip states (unless #skip_state_validation? is
+    # truthy).
+    def ensure_order_is_not_skipping_states
+      if params[:state]
+        redirect_to checkout_state_path(@order.state) if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
+        @order.state = params[:state]
+      end
+    end
+
+    def set_state_if_present
+      ensure_order_is_not_skipping_states
+    end
+    deprecate set_state_if_present: :prevent_order_from_skipping_states, deprecator: Spree::Deprecation
+
+    def ensure_checkout_allowed
+      unless @order.checkout_allowed?
+        redirect_to spree.cart_path
+      end
+    end
+
+    def ensure_order_not_completed
+      redirect_to spree.cart_path if @order.completed?
+    end
+
+    def ensure_sufficient_stock_lines
+      if @order.insufficient_stock_lines.present?
+        out_of_stock_items = @order.insufficient_stock_lines.collect(&:name).to_sentence
+        flash[:error] = t('spree.inventory_error_flash_for_insufficient_quantity', names: out_of_stock_items)
+        redirect_to spree.cart_path
+      end
+    end
+
+    # Provides a route to redirect after order completion
+    def completion_route
+      spree.order_path(@order)
+    end
+
+    def setup_for_current_state
+      method_name = :"before_#{@order.state}"
+      send(method_name) if respond_to?(method_name, true)
+    end
+
+    def before_address
+      @order.assign_default_user_addresses
+      # If the user has a default address, the previous method call takes care
+      # of setting that; but if he doesn't, we need to build an empty one here
+      @order.bill_address ||= Spree::Address.build_default
+      @order.ship_address ||= Spree::Address.build_default if @order.checkout_steps.include?('delivery')
+    end
+
+    def before_delivery
+      return if params[:order].present?
+
+      packages = @order.shipments.map(&:to_package)
+      @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+    end
+
+    def before_payment
+      if @order.checkout_steps.include? "delivery"
+        packages = @order.shipments.map(&:to_package)
+        @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+        @differentiator.missing.each do |variant, quantity|
+          @order.contents.remove(variant, quantity)
+        end
+      end
+
+      if try_spree_current_user && try_spree_current_user.respond_to?(:wallet)
+        @wallet_payment_sources = try_spree_current_user.wallet.wallet_payment_sources
+        @default_wallet_payment_source = @wallet_payment_sources.detect(&:default) ||
+                                         @wallet_payment_sources.first
+      end
+    end
+
+    def rescue_from_spree_gateway_error(exception)
+      flash.now[:error] = t('spree.spree_gateway_error_flash_for_checkout')
+      @order.errors.add(:base, exception.message)
+      render :edit
+    end
+
+    def check_authorization
+      authorize!(:edit, current_order, cookies.signed[:guest_token])
+    end
+
+    def insufficient_stock_error
+      packages = @order.shipments.map(&:to_package)
+      if packages.empty?
+        flash[:error] = I18n.t('spree.insufficient_stock_for_order')
+        redirect_to cart_path
+      else
+        availability_validator = Spree::Stock::AvailabilityValidator.new
+        unavailable_items = @order.line_items.reject { |line_item| availability_validator.validate(line_item) }
+        if unavailable_items.any?
+          item_names = unavailable_items.map(&:name).to_sentence
+          flash[:error] = t('spree.inventory_error_flash_for_insufficient_shipment_quantity', unavailable_items: item_names)
+          @order.restart_checkout_flow
+          redirect_to spree.checkout_state_path(@order.state)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/coupon_codes_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  class CouponCodesController < Spree::StoreController
+    before_action :load_order, only: :create
+    around_action :lock_order, only: :create
+
+    def create
+      authorize! :update, @order, cookies.signed[:guest_token]
+
+      if params[:coupon_code].present?
+        @order.coupon_code = params[:coupon_code]
+        handler = PromotionHandler::Coupon.new(@order).apply
+
+        respond_with(@order) do |format|
+          format.html do
+            if handler.successful?
+              flash[:success] = handler.success
+            else
+              flash[:error] = handler.error
+            end
+
+            redirect_back fallback_location: cart_path
+          end
+        end
+      end
+    end
+
+    private
+
+    def load_order
+      @order = current_order
+    end
+  end
+end

data/app/controllers/spree/home_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  class HomeController < Spree::StoreController
+    helper 'spree/products'
+    respond_to :html
+
+    def index
+      @searcher = build_searcher(params.merge(include_images: true))
+      @products = @searcher.retrieve_products
+    end
+  end
+end

data/app/controllers/spree/locale_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  class LocaleController < Spree::StoreController
+    def set
+      available_locales = Spree.i18n_available_locales
+      requested_locale = params[:switch_to_locale] || params[:locale]
+
+      if requested_locale && available_locales.map(&:to_s).include?(requested_locale)
+        session[set_user_language_locale_key] = requested_locale
+        I18n.locale = requested_locale
+        flash.notice = t('spree.locale_changed')
+      else
+        flash[:error] = t('spree.locale_not_changed')
+      end
+
+      redirect_to spree.root_path
+    end
+  end
+end

data/app/controllers/spree/orders_controller.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrdersController < Spree::StoreController
+    helper 'spree/products', 'spree/orders'
+
+    respond_to :html
+
+    before_action :store_guest_token
+    before_action :assign_order, only: :update
+    # note: do not lock the #edit action because that's where we redirect when we fail to acquire a lock
+    around_action :lock_order, only: :update
+    skip_before_action :verify_authenticity_token, only: [:populate]
+
+    def show
+      @order = Spree::Order.find_by!(number: params[:id])
+      authorize! :read, @order, cookies.signed[:guest_token]
+    end
+
+    def update
+      authorize! :update, @order, cookies.signed[:guest_token]
+      if @order.contents.update_cart(order_params)
+        @order.next if params.key?(:checkout) && @order.cart?
+
+        respond_with(@order) do |format|
+          format.html do
+            if params.key?(:checkout)
+              redirect_to checkout_state_path(@order.checkout_steps.first)
+            else
+              redirect_to cart_path
+            end
+          end
+        end
+      else
+        respond_with(@order)
+      end
+    end
+
+    # Shows the current incomplete order from the session
+    def edit
+      @order = current_order(build_order_if_necessary: true)
+      authorize! :read, @order, cookies.signed[:guest_token]
+      associate_user
+      if params[:id] && @order.number != params[:id]
+        flash[:error] = t('spree.cannot_edit_orders')
+        redirect_to cart_path
+      end
+    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)
+      authorize! :update, @order, cookies.signed[:guest_token]
+
+      variant  = Spree::Variant.find(params[:variant_id])
+      quantity = params[:quantity].present? ? params[:quantity].to_i : 1
+
+      # 2,147,483,647 is crazy. See issue https://github.com/spree/spree/issues/2695.
+      if !quantity.between?(1, 2_147_483_647)
+        @order.errors.add(:base, t('spree.please_enter_reasonable_quantity'))
+      else
+        begin
+          @line_item = @order.contents.add(variant, quantity)
+        rescue ActiveRecord::RecordInvalid => e
+          @order.errors.add(:base, e.record.errors.full_messages.join(", "))
+        end
+      end
+
+      respond_with(@order) do |format|
+        format.html do
+          if @order.errors.any?
+            flash[:error] = @order.errors.full_messages.join(", ")
+            redirect_back_or_default(spree.root_path)
+            return
+          else
+            redirect_to cart_path
+          end
+        end
+      end
+    end
+
+    def populate_redirect
+      flash[:error] = t('spree.populate_get_error')
+      redirect_to spree.cart_path
+    end
+
+    def empty
+      if @order = current_order
+        authorize! :update, @order, cookies.signed[:guest_token]
+        @order.empty!
+      end
+
+      redirect_to spree.cart_path
+    end
+
+    def accurate_title
+      if @order && @order.completed?
+        t('spree.order_number', number: @order.number)
+      else
+        t('spree.shopping_cart')
+      end
+    end
+
+    private
+
+    def store_guest_token
+      cookies.permanent.signed[:guest_token] = params[:token] if params[:token]
+    end
+
+    def order_params
+      if params[:order]
+        params[:order].permit(*permitted_order_attributes)
+      else
+        {}
+      end
+    end
+
+    def assign_order
+      @order = current_order
+      unless @order
+        flash[:error] = t('spree.order_not_found')
+        redirect_to(root_path) && return
+      end
+    end
+  end
+end