spree_storefront 5.0.0.rc1

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,365 @@
+module Spree
+  class CheckoutController < StoreController
+    include Spree::BaseHelper
+    include Spree::CheckoutHelper
+    include Spree::CheckoutAnalyticsHelper
+
+    before_action :require_user, unless: -> { current_store.prefers_guest_checkout? }
+    before_action :load_order
+    before_action :remove_out_of_stock_items, only: [:edit, :update]
+
+    before_action :set_cache_header, only: [:edit]
+    before_action :ensure_valid_state_lock_version, only: [:update]
+    before_action :set_state_if_present, only: [:edit, :update]
+
+    before_action :ensure_order_not_completed, only: [:edit, :update]
+    before_action :ensure_checkout_allowed
+    before_action :ensure_valid_state, only: [:edit, :update]
+
+    before_action :restart_checkout, only: :edit, if: :should_restart_checkout?
+
+    before_action :setup_for_current_state, only: [:edit, :update]
+
+    before_action :remove_expired_gift_card, only: :edit
+
+    before_action :store_location, only: :edit
+
+    after_action :clean_analytics_session, only: :edit
+    after_action :clear_checkout_completed_session, only: [:complete]
+
+    rescue_from Spree::Core::GatewayError, with: :rescue_from_spree_gateway_error
+
+    layout 'spree/checkout'
+
+    # GET /checkout/<token>
+    def edit
+      if checkout_started?
+        track_checkout_started
+
+        @order.accept_marketing = true # TODO: move this to store preferences
+        @order.signup_for_an_account = true # TODO: move this to store preferences
+      end
+
+      track_checkout_step_viewed
+    end
+
+    # PATCH /checkout/<token>
+    # Updates the order and advances to the next state (when possible.)
+    # Passing params[:do_not_advance] = true only updates order without the need to advance to the next state.
+    def update
+      @previous_state = @order.state
+
+      if @order.update_from_params(params, permitted_checkout_attributes, request.headers.env)
+        track_checkout_entered_email
+        track_payment_info_entered
+        track_checkout_step_completed
+
+        unless params[:do_not_advance]
+          @order.temporary_address = !params[:save_user_address]
+          unless @order.next
+            return if @order.address? && @order.line_items_without_shipping_rates.any? && turbo_stream_request? # render update trubo_stream
+
+            flash[:error] = @order.errors.messages.values.flatten.join("\n")
+            redirect_to(spree.checkout_state_path(@order.token, @order.state)) && return
+          end
+
+          if @order.completed?
+            track_checkout_completed
+            redirect_to spree.checkout_complete_path(@order.token), status: :see_other
+          else
+            redirect_to spree.checkout_state_path(@order.token, @order.state)
+          end
+        end
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # DELETE /checkout/<token>/remove_missing_items
+    def remove_missing_items
+      line_items_to_remove = @order.line_items.where(id: params[:line_item_ids])
+
+      ApplicationRecord.transaction do
+        line_items_to_remove.each do |line_item|
+          remove_line_item_service.call(order: @order, line_item: line_item)
+        end
+      end
+
+      redirect_to spree.checkout_path(@order.token)
+    end
+
+    # GET /checkout/<token>/complete
+    def complete
+      clear_order_token
+    end
+
+    # PATCH /checkout/<token>/coupon_code
+    def apply_coupon_code
+      @order.coupon_code = params[:coupon_code]
+      @result = coupon_handler.new(@order, { email: params[:promotion_email] }).apply
+
+      track_event('coupon_entered', coupon_tracking_params)
+
+      if @result&.successful?
+        track_event('coupon_applied', coupon_tracking_params)
+      else
+        track_event('coupon_denied', coupon_tracking_params)
+      end
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html do
+          if @result&.successful?
+            flash[:success] = 'Coupon applied successfully'
+          else
+            flash[:error] = @result&.error
+          end
+          redirect_to spree.checkout_path(@order.token)
+        end
+      end
+    end
+
+    # DELETE /checkout/<token>/coupon_code
+    def remove_coupon_code
+      @result = coupon_handler.new(@order).remove(params[:coupon_code] || params[:gift_card])
+
+      track_event('coupon_removed', coupon_tracking_params) if @result.successful?
+      params.delete(:coupon_code)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.checkout_path(@order.token) }
+      end
+    end
+
+    def apply_store_credit
+      add_store_credit_service.call(order: @order)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.checkout_path(@order.token) }
+      end
+    end
+
+    def remove_store_credit
+      remove_store_credit_service.call(order: @order)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.checkout_path(@order.token) }
+      end
+    end
+
+    private
+
+    # rather then using cookies like in old Spree we're going to fetch the order based on the
+    # token passed in the parameters, this allows us to share carts, send payment links, etc
+    def load_order
+      return @order if @order.present?
+
+      orders_scope = if action_name == 'complete'
+                       current_store.orders.complete
+                     else
+                       current_store.orders.incomplete
+                     end
+
+      # we shouldn't lock the order here, because we're not going to update it
+      lock = !['complete', 'edit'].include?(action_name)
+
+      @order = orders_scope.lock(lock).find_by(token: params[:token])
+
+      if @order.nil?
+        clear_order_token
+        redirect_to_cart and return
+      end
+
+      if @order.user_id.present?
+        if try_spree_current_user.present? && @order.user_id != try_spree_current_user.id
+          clear_order_token
+          flash[:error] = 'You cannot access this checkout'
+          redirect_to_cart
+        elsif try_spree_current_user.nil? && !@order.completed?
+          store_location
+          redirect_to spree_login_path
+        end
+      end
+
+      # completed orders shouldn't be updated anymore
+      unless @order.completed?
+        @order.assign_attributes(order_tracking_params)
+        @order.update_columns(order_tracking_params)
+        @order.associate_user!(try_spree_current_user) if try_spree_current_user && @order.user.nil?
+      end
+      @current_order = @order # for compatibility with the rest of storefront, analytics, etc
+    end
+
+    def remove_out_of_stock_items
+      _validated_order, messages = Spree::Cart::RemoveOutOfStockItems.call(order: @order).value
+
+      if messages.any?
+        flash[:error] = messages.to_sentence
+        redirect_to_cart
+      end
+    end
+
+    def unknown_state?
+      (params[:state] && !@order.has_checkout_step?(params[:state])) ||
+        (!params[:state] && !@order.has_checkout_step?(@order.state))
+    end
+
+    def insufficient_payment?
+      params[:state] == 'confirm' &&
+        @order.payment_required? &&
+        @order.payments.valid.sum(:amount) != @order.total
+    end
+
+    def correct_state
+      if unknown_state?
+        @order.checkout_steps.first
+      elsif insufficient_payment?
+        'payment'
+      elsif @order.state == 'cart'
+        'address'
+      elsif @order.digital? && @order.delivery?
+        'address'
+      else
+        @order.state
+      end
+    end
+
+    def ensure_valid_state
+      redirect_to_state(correct_state) if @order.state != correct_state && !skip_state_validation?
+    end
+
+    def redirect_to_state(state)
+      flash.keep
+      @order.update_column(:state, state)
+      # GL is GA4 parameter needed to persist user's session between custom storefront and checkout
+      redirect_to spree.checkout_state_path(@order.token, @order.state, _gl: params[:_gl].presence)
+    end
+
+    def should_restart_checkout?
+      (@order.quick_checkout? || @order.ship_address.nil?) && (@order.delivery? || @order.payment?)
+    end
+
+    def restart_checkout
+      @order.update!(ship_address: nil)
+      redirect_to_state('address')
+    end
+
+    def skip_state_validation?
+      %w(complete).include?(params[:action])
+    end
+
+    def ensure_valid_state_lock_version
+      if params[:order] && params[:order][:state_lock_version]
+        changes = @order.changes.transform_values(&:last).symbolize_keys if @order.changed?
+        @order.reload.with_lock do
+          unless @order.state_lock_version == params[:order].delete(:state_lock_version).to_i
+            flash[:error] = Spree.t(:order_already_updated)
+            redirect_to(checkout_state_path(@order.token, @order.state)) && return
+          end
+          @order.increment!(:state_lock_version)
+        end
+        @order.assign_attributes(changes) if changes
+      end
+    end
+
+    def set_state_if_present
+      if params[:state] && params[:state] != 'complete'
+        redirect_to spree.checkout_state_path(@order.token, @order.state) if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
+        @order.state = params[:state]
+      end
+    end
+
+    def ensure_checkout_allowed
+      return if @order.checkout_allowed?
+
+      redirect_to_cart
+    end
+
+    def ensure_order_not_completed
+      return unless @order.completed?
+
+      clear_order_token
+      redirect_to_cart
+    end
+
+    def setup_for_current_state
+      method_name = :"before_#{@order.state}"
+      send(method_name) if respond_to?(method_name, true)
+    end
+
+    def before_address
+      if try_spree_current_user.present?
+        @order.ship_address ||= try_spree_current_user.ship_address
+        @order.bill_address ||= try_spree_current_user.bill_address
+      end
+      # for guest users or users without addresses, we need to build an empty one here
+      @order.ship_address ||= Address.new(country: current_store.default_country, user: try_spree_current_user)
+    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
+      @order.bill_address ||= @order.ship_address.clone
+
+      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|
+          Spree::Dependencies.cart_remove_item_service.constantize.call(order: @order, variant: variant, quantity: quantity)
+        end
+      end
+    end
+
+    def rescue_from_spree_gateway_error(exception)
+      Rails.error.report(
+        exception,
+        context: { order_id: @order&.id, order_number: @order&.number, error_type: 'gateway_error' },
+        source: 'spree.storefront'
+      )
+
+      flash.now[:error] = Spree.t(:spree_gateway_error_flash_for_checkout)
+      @order.errors.add(:base, exception.message)
+      render :edit, status: :unprocessable_entity
+    end
+
+    # we don't want to browser cache the checkout page
+    def set_cache_header
+      response.headers['Cache-Control'] = 'no-store'
+    end
+
+    def add_store_credit_service
+      Spree::Dependencies.checkout_add_store_credit_service.constantize
+    end
+
+    def remove_store_credit_service
+      Spree::Dependencies.checkout_remove_store_credit_service.constantize
+    end
+
+    def remove_line_item_service
+      Spree::Dependencies.cart_remove_line_item_service.constantize
+    end
+
+    def coupon_handler
+      Spree::Dependencies.coupon_handler.constantize
+    end
+
+    def accurate_title
+      Spree.t(:checkout)
+    end
+
+    def remove_expired_gift_card
+      return unless defined?(Spree::GiftCards::Remove)
+      return unless @order.gift_card.present? && @order.gift_card.expired?
+
+      Spree::GiftCards::Remove.call(order: @order)
+    end
+  end
+end

data/app/controllers/spree/contacts_controller.rb

@@ -0,0 +1,46 @@
+module Spree
+  class ContactsController < StoreController
+    before_action :load_store
+    before_action :ensure_customer_support_email
+
+    def new
+      @contact = Spree::Contact.new
+    end
+
+    def create
+      @contact = Spree::Contact.new(params[:contact])
+      @contact.customer_support_email = current_store.customer_support_email
+      @contact.request = request
+
+      if @contact.deliver
+        flash[:success] = Spree.t('storefront.contacts.message_sent')
+      else
+        message_not_sent
+      end
+      redirect_to action: :new
+    end
+
+    private
+
+    def load_store
+      @store = current_store
+    end
+
+    def message_not_sent(exception = nil)
+      Rails.error.report(
+        exception || StandardError.new('Contact Form Message not sent'),
+        context: { contact_id: @contact&.id },
+        source: 'spree.storefront'
+      )
+
+      flash[:error] = Spree.t('storefront.contacts.message_not_sent')
+    end
+
+    def ensure_customer_support_email
+      return if current_store.customer_support_email.present?
+
+      flash[:error] = Spree.t('storefront.contacts.customer_support_email_not_configured')
+      redirect_back_or_default root_path
+    end
+  end
+end

data/app/controllers/spree/digital_links_controller.rb

@@ -0,0 +1,48 @@
+module Spree
+  class DigitalLinksController < StoreController
+    def show
+      if digital_link.authorize!
+        mark_shipment_as_fullfiled if digital_link.access_counter == 1
+
+        if defined?(ActiveStorage::Service::DiskService) && ActiveStorage::Blob.service.instance_of?(ActiveStorage::Service::DiskService)
+          send_file(
+            ActiveStorage::Blob.service.path_for(attachment.key),
+            filename: digital_link.filename.to_s,
+            type: digital_link.content_type.to_s,
+            status: :ok
+            ) and return
+        else
+          redirect_to attachment.url(
+            expires_in: current_store.preferred_digital_asset_link_expire_time.seconds,
+            disposition: 'attachment'
+          ), allow_other_host: true and return
+        end
+      end
+
+      flash[:error] = Spree.t(:digital_link_unauthorized)
+      redirect_to spree.order_path(digital_link.order)
+    end
+
+    private
+
+    def mark_shipment_as_fullfiled
+      ActiveRecord::Base.connected_to(role: :writing) do
+        Spree::Shipment.transaction do
+          shipments.each(&:ship)
+        end
+      end
+    end
+
+    def digital_link
+      @digital_link ||= current_store.digital_links.find_by!(token: params[:id])
+    end
+
+    def shipments
+      @shipments ||= digital_link.line_item.shipments.digital_delivery
+    end
+
+    def attachment
+      @attachment ||= digital_link.digital.attachment
+    end
+  end
+end

data/app/controllers/spree/home_controller.rb

@@ -0,0 +1,5 @@
+module Spree
+  class HomeController < Spree::StoreController
+    def index; end
+  end
+end

data/app/controllers/spree/line_items_controller.rb

@@ -0,0 +1,96 @@
+module Spree
+  class LineItemsController < Spree::StoreController
+    include CartMethods
+
+    before_action :load_variant, only: :create
+    before_action :assign_order_with_lock, except: :create
+    before_action :load_line_item, except: :create
+
+    skip_before_action :verify_authenticity_token, only: :create
+
+    helper 'spree/products'
+
+    def create
+      @order    = current_order(create_order_if_necessary: true)
+      @quantity = params[:quantity].to_i || 1
+      options   = params[:options] || {}
+
+      cookies.permanent.signed[:token] = @order.token if @order.persisted?
+
+      result = cart_add_item_service.call(order: @order,
+                                          variant: @variant,
+                                          quantity: @quantity,
+                                          options: options)
+
+      flash.now[:error] = result.value.errors.full_messages.to_sentence if result.failure?
+
+      @line_item = result.value
+
+      if result.success?
+        load_line_items
+
+        track_event('product_added', { line_item: @line_item })
+      else
+        @error = result.value.errors.full_messages.to_sentence
+        flash.now[:error] = @error
+      end
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.cart_path(order_token: order_token) }
+      end
+    end
+
+    def update
+      quantity = line_item_params[:quantity]&.to_i || 1
+      result = cart_set_item_quantity_service.call(order: @order, line_item: @line_item, quantity: quantity)
+
+      @error = result.value.errors.full_messages.to_sentence if result.failure?
+
+      load_line_items if result.success?
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.cart_path(order_token: order_token) }
+      end
+    end
+
+    def destroy
+      result = cart_remove_line_item_service.call(order: @order, line_item: @line_item)
+      load_line_items if result.success?
+
+      track_event('product_removed', { line_item: @line_item })
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to spree.cart_path(order_token: order_token) }
+      end
+    end
+
+    protected
+
+    def load_variant
+      @variant = current_store.variants.find(params[:variant_id])
+    end
+
+    def load_line_item
+      @line_item = @order.line_items.find(params[:id])
+    end
+
+    def line_item_params
+      params.require(:line_item).permit(*permitted_line_item_attributes)
+    end
+
+    def cart_add_item_service
+      Spree::Dependencies.cart_add_item_service.constantize
+    end
+
+    def cart_remove_line_item_service
+      Spree::Dependencies.cart_remove_line_item_service.constantize
+    end
+
+    def cart_set_item_quantity_service
+      Spree::Dependencies.cart_set_item_quantity_service.constantize
+    end
+  end
+end

data/app/controllers/spree/newsletter_subscribers_controller.rb

@@ -0,0 +1,43 @@
+module Spree
+  class NewsletterSubscribersController < StoreController
+    skip_before_action :redirect_to_password
+    before_action :load_newsletter_section, only: :create
+
+    # POST /newsletter_subscribers
+    def create
+      user = Spree.user_class.find_or_initialize_by(email: newsletter_params[:email])
+
+      if user.new_record? && user.respond_to?(:password) && user.respond_to?(:password_confirmation)
+        user.password ||= SecureRandom.hex(16) # we need to set a password to pass validation
+        user.password_confirmation ||= user.password
+      end
+
+      user.accepts_email_marketing = true if user.new_record? || try_spree_current_user == user
+
+      if user.save
+        track_event('subscribed_to_newsletter', { email: user.email, user: user })
+
+        flash[:success] = Spree.t('storefront.newsletter_subscribers.success')
+      else
+        flash[:error] = user.errors.full_messages.to_sentence.presence || Spree.t('something_went_wrong')
+      end
+
+      respond_to do |format|
+        format.html { redirect_to spree.root_path }
+        format.turbo_stream
+      end
+    end
+
+    private
+
+    def newsletter_params
+      params.require(:newsletter).permit(:email)
+    end
+
+    def load_newsletter_section
+      return if params[:section_id].blank?
+
+      @newsletter_section = Spree::PageSections::Newsletter.find_by(id: params[:section_id])
+    end
+  end
+end

data/app/controllers/spree/order_status_controller.rb

@@ -0,0 +1,32 @@
+module Spree
+  class OrderStatusController < StoreController
+    # page for user to input their email address and order number
+    # GET /order_status
+    def new; end
+
+    # validate email/order number and redirect to order page
+    # POST /order_status
+    def create
+      raise ActiveRecord::RecordNotFound if params[:number].blank?
+
+      @order = order_finder.new(number: params[:number], email: params[:email], store: current_store).execute.first
+
+      if @order
+        redirect_to spree.order_path(@order, token: @order.token), status: :see_other
+      else
+        flash[:error] = Spree.t(:order_not_found)
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def accurate_title
+      Spree.t(:order_status)
+    end
+
+    def order_finder
+      Spree::Dependencies.completed_order_finder.constantize
+    end
+  end
+end