goca-spree-frontend 3.1.14.rails.5.0

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,205 @@
+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 waranted.
+  class CheckoutController < Spree::StoreController
+    before_action :expires_now, only: [:edit]
+    before_action :load_order_with_lock
+    before_action :ensure_valid_state_lock_version, only: [:update]
+    before_action :set_state_if_present
+
+    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 :apply_coupon_code
+
+    before_action :setup_for_current_state
+    before_action :add_store_credit_payments, only: [:update]
+
+    helper 'spree/orders'
+
+    rescue_from Spree::Core::GatewayError, with: :rescue_from_spree_gateway_error
+
+    # Updates the order and advances to the next state (when possible.)
+    def update
+      if @order.update_from_params(params, permitted_checkout_attributes, request.headers.env)
+        @order.temporary_address = !params[:save_user_address]
+        unless @order.next
+          flash[:error] = @order.errors.full_messages.join("\n")
+          redirect_to(checkout_state_path(@order.state)) && return
+        end
+
+        if @order.completed?
+          @current_order = nil
+          flash.notice = Spree.t(:order_processed_successfully)
+          flash['order_completed'] = true
+          redirect_to completion_route
+        else
+          redirect_to checkout_state_path(@order.state)
+        end
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    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'
+      else
+        @order.state
+      end
+    end
+
+    def ensure_valid_state
+      if @order.state != correct_state && !skip_state_validation?
+        flash.keep
+        @order.update_column(:state, correct_state)
+        redirect_to checkout_state_path(@order.state)
+      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_with_lock
+      @order = current_order(lock: true)
+      redirect_to(spree.cart_path) && return unless @order
+    end
+
+    def ensure_valid_state_lock_version
+      if params[:order] && params[:order][:state_lock_version]
+        @order.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.state)) && return
+          end
+          @order.increment!(:state_lock_version)
+        end
+      end
+    end
+
+    def set_state_if_present
+      if params[:state]
+        if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
+          redirect_to checkout_state_path(@order.state)
+        end
+        @order.state = params[:state]
+      end
+    end
+
+    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?
+        flash[:error] = Spree.t(:inventory_error_flash_for_insufficient_quantity)
+        redirect_to spree.cart_path
+      end
+    end
+
+    # Provides a route to redirect after order completion
+    def completion_route(custom_params = nil)
+      spree.order_path(@order, custom_params)
+    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 the user has a default address, a callback takes care of setting
+      # that; but if he doesn't, we need to build an empty one here
+      @order.bill_address ||= Address.build_default
+      @order.ship_address ||= 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?(:payment_sources)
+        @payment_sources = try_spree_current_user.payment_sources
+      end
+    end
+
+    def add_store_credit_payments
+      if params.has_key?(:apply_store_credit)
+        @order.add_store_credit_payments
+
+        # Remove other payment method parameters.
+        params[:order].delete(:payments_attributes)
+        params.delete(:payment_source)
+
+        # Return to the Payments page if additional payment is needed.
+        if @order.payments.valid.sum(:amount) < @order.total
+          redirect_to checkout_state_path(@order.state) and return
+        end
+      end
+    end
+
+    def rescue_from_spree_gateway_error(exception)
+      flash.now[:error] = Spree.t(: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 sanitize_zip_code
+      order_params = params[:order]
+      return unless order_params
+      strip_zip(order_params[:bill_address_attributes])
+      strip_zip(order_params[:ship_address_attributes])
+    end
+
+    def strip_zip(address_params)
+      return unless address_params
+      address_params[:zipcode] = address_params[:zipcode].strip if address_params[:zipcode]
+    end
+  end
+end

data/app/controllers/spree/content_controller.rb

@@ -0,0 +1,23 @@
+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
+
+    rescue_from ActionView::MissingTemplate, :with => :render_404
+
+    respond_to :html
+
+    def show
+      render :action => params[:path]
+    end
+
+    def cvv
+      render :layout => false
+    end
+
+    def fire_visited_path
+      Spree::PromotionHandler::Page.new(current_order, params[:path]).activate
+    end
+  end
+end

data/app/controllers/spree/home_controller.rb

@@ -0,0 +1,13 @@
+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
+      @products = @products.includes(:possible_promotions) if @products.respond_to?(:includes)
+      @taxonomies = Spree::Taxonomy.includes(root: :children)
+    end
+  end
+end

data/app/controllers/spree/locale_controller.rb

@@ -0,0 +1,16 @@
+module Spree
+  class LocaleController < Spree::StoreController
+    def set
+      if request.referer && request.referer.starts_with?('http://' + request.host)
+        session['user_return_to'] = request.referer
+      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)
+      else
+        flash[:error] = Spree.t(:locale_not_changed)
+      end
+      redirect_back_or_default(spree.root_path)
+    end
+  end
+end

data/app/controllers/spree/orders_controller.rb

@@ -0,0 +1,113 @@
+module Spree
+  class OrdersController < Spree::StoreController
+    before_action :check_authorization
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/products', 'spree/orders'
+
+    respond_to :html
+
+    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])
+    end
+
+    def update
+      if @order.contents.update_cart(order_params)
+        respond_with(@order) do |format|
+          format.html do
+            if params.has_key?(:checkout)
+              @order.next if @order.cart?
+              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 || Order.incomplete.
+                                  includes(line_items: [variant: [:images, :option_values, :product]]).
+                                  find_or_initialize_by(guest_token: cookies.signed[:guest_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
+
+      redirect_to spree.cart_path
+    end
+
+    def accurate_title
+      if @order && @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
+
+      if order
+        authorize! :edit, order, cookies.signed[:guest_token]
+      else
+        authorize! :create, Spree::Order
+      end
+    end
+
+    private
+
+      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
+      end
+  end
+end

data/app/controllers/spree/products_controller.rb

@@ -0,0 +1,60 @@
+module Spree
+  class ProductsController < Spree::StoreController
+    before_action :load_product, only: :show
+    before_action :load_taxon, only: :index
+
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/taxons'
+
+    respond_to :html
+
+    def index
+      @searcher = build_searcher(params.merge(include_images: true))
+      @products = @searcher.retrieve_products
+      @products = @products.includes(:possible_promotions) if @products.respond_to?(:includes)
+      @taxonomies = Spree::Taxonomy.includes(root: :children)
+    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
+
+      def accurate_title
+        if @product
+          @product.meta_title.blank? ? @product.name : @product.meta_title
+        else
+          super
+        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, variant_images: :viewable).friendly.find(params[:id])
+      end
+
+      def load_taxon
+        @taxon = Spree::Taxon.find(params[:taxon]) if params[:taxon].present?
+      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
+      end
+  end
+end

data/app/controllers/spree/store_controller.rb

@@ -0,0 +1,44 @@
+module Spree
+  class StoreController < Spree::BaseController
+    include Spree::Core::ControllerHelpers::Order
+
+    skip_before_action :set_current_order, only: :cart_link
+
+    def forbidden
+      render 'spree/shared/forbidden', layout: Spree::Config[:layout], status: 403
+    end
+
+    def unauthorized
+      render 'spree/shared/unauthorized', layout: Spree::Config[:layout], status: 401
+    end
+
+    def cart_link
+      render partial: 'spree/shared/link_to_cart'
+      fresh_when(simple_current_order)
+    end
+
+    protected
+
+    # 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]
+
+        handler = PromotionHandler::Coupon.new(@order).apply
+
+        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
+        end
+      end
+    end
+
+    def config_locale
+      Spree::Frontend::Config[:locale]
+    end
+  end
+end

data/app/controllers/spree/taxons_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  class TaxonsController < Spree::StoreController
+    rescue_from ActiveRecord::RecordNotFound, with: :render_404
+    helper 'spree/products'
+
+    respond_to :html
+
+    def show
+      @taxon = Taxon.friendly.find(params[:id])
+      return unless @taxon
+
+      @searcher = build_searcher(params.merge(taxon: @taxon.id, include_images: true))
+      @products = @searcher.retrieve_products
+      @taxonomies = Spree::Taxonomy.includes(root: :children)
+    end
+
+    private
+
+    def accurate_title
+      @taxon.try(:seo_title) || super
+    end
+  end
+end

data/app/helpers/spree/frontend_helper.rb

@@ -0,0 +1,95 @@
+module Spree
+  module FrontendHelper
+    def body_class
+      @body_class ||= content_for?(:sidebar) ? 'two-col' : 'one-col'
+      @body_class
+    end
+
+    def breadcrumbs(taxon, separator=" ")
+      return "" if current_page?("/") || taxon.nil?
+      separator = raw(separator)
+      crumbs = [content_tag(:li, content_tag(:span, link_to(content_tag(:span, Spree.t(:home), itemprop: "name"), spree.root_path, itemprop: "url") + separator, itemprop: "item"), itemscope: "itemscope", itemtype: "https://schema.org/ListItem", itemprop: "itemListElement")]
+      if taxon
+        crumbs << content_tag(:li, content_tag(:span, link_to(content_tag(:span, Spree.t(:products), itemprop: "name"), spree.products_path, itemprop: "url") + separator, itemprop: "item"), itemscope: "itemscope", itemtype: "https://schema.org/ListItem", itemprop: "itemListElement")
+        crumbs << taxon.ancestors.collect { |ancestor| content_tag(:li, content_tag(:span, link_to(content_tag(:span, ancestor.name, itemprop: "name"), seo_url(ancestor), itemprop: "url") + separator, itemprop: "item"), itemscope: "itemscope", itemtype: "https://schema.org/ListItem", itemprop: "itemListElement") } unless taxon.ancestors.empty?
+        crumbs << content_tag(:li, content_tag(:span, link_to(content_tag(:span, taxon.name, itemprop: "name") , seo_url(taxon), itemprop: "url"), itemprop: "item"), class: 'active', itemscope: "itemscope", itemtype: "https://schema.org/ListItem", itemprop: "itemListElement")
+      else
+        crumbs << content_tag(:li, content_tag(:span, Spree.t(:products), itemprop: "item"), class: 'active', itemscope: "itemscope", itemtype: "https://schema.org/ListItem", itemprop: "itemListElement")
+      end
+      crumb_list = content_tag(:ol, raw(crumbs.flatten.map{|li| li.mb_chars}.join), class: 'breadcrumb', itemscope: "itemscope", itemtype: "https://schema.org/BreadcrumbList")
+      content_tag(:nav, crumb_list, id: 'breadcrumbs', class: 'col-md-12')
+    end
+
+    def checkout_progress(numbers: false)
+      states = @order.checkout_steps
+      items = states.each_with_index.map do |state, i|
+        text = Spree.t("order_state.#{state}").titleize
+        text.prepend("#{i.succ}. ") if numbers
+
+        css_classes = []
+        current_index = states.index(@order.state)
+        state_index = states.index(state)
+
+        if state_index < current_index
+          css_classes << 'completed'
+          text = link_to text, checkout_state_path(state)
+        end
+
+        css_classes << 'next' if state_index == current_index + 1
+        css_classes << 'active' if state == @order.state
+        css_classes << 'first' if state_index == 0
+        css_classes << 'last' if state_index == states.length - 1
+        # No more joined classes. IE6 is not a target browser.
+        # Hack: Stops <a> being wrapped round previous items twice.
+        if state_index < current_index
+          content_tag('li', text, class: css_classes.join(' '))
+        else
+          content_tag('li', content_tag('a', text), class: css_classes.join(' '))
+        end
+      end
+      content_tag('ul', raw(items.join("\n")), class: 'progress-steps nav nav-pills nav-justified', id: "checkout-step-#{@order.state}")
+    end
+
+    def flash_messages(opts = {})
+      ignore_types = ["order_completed"].concat(Array(opts[:ignore_types]).map(&:to_s) || [])
+
+      flash.each do |msg_type, text|
+        unless ignore_types.include?(msg_type)
+          concat(content_tag :div, text, class: "alert alert-#{msg_type}")
+        end
+      end
+      nil
+    end
+
+    def link_to_cart(text = nil)
+      text = text ? h(text) : Spree.t('cart')
+      css_class = nil
+
+      if simple_current_order.nil? or simple_current_order.item_count.zero?
+        text = "<span class='glyphicon glyphicon-shopping-cart'></span> #{text}: (#{Spree.t('empty')})"
+        css_class = 'empty'
+      else
+        text = "<span class='glyphicon glyphicon-shopping-cart'></span> #{text}: (#{simple_current_order.item_count})  <span class='amount'>#{simple_current_order.display_total.to_html}</span>"
+        css_class = 'full'
+      end
+
+      link_to text.html_safe, spree.cart_path, :class => "cart-info #{css_class}"
+    end
+
+    # helper to determine if its appropriate to show the store menu
+    def store_menu?
+      %w{thank_you}.exclude? params[:action]
+    end
+
+    def taxons_tree(root_taxon, current_taxon, max_level = 1)
+      return '' if max_level < 1 || root_taxon.leaf?
+      content_tag :div, class: 'list-group' do
+        taxons = root_taxon.children.map do |taxon|
+          css_class = (current_taxon && current_taxon.self_and_ancestors.include?(taxon)) ? 'list-group-item active' : 'list-group-item'
+          link_to(taxon.name, seo_url(taxon), class: css_class) + taxons_tree(taxon, current_taxon, max_level - 1)
+        end
+        safe_join(taxons, "\n")
+      end
+    end
+  end
+end

data/app/helpers/spree/orders_helper.rb

@@ -0,0 +1,16 @@
+require 'truncate_html'
+require 'app/helpers/truncate_html_helper'
+
+module Spree
+  module OrdersHelper
+    include TruncateHtmlHelper
+
+    def truncated_product_description(product)
+      truncate_html(raw(product.description))
+    end
+
+    def order_just_completed?(order)
+      flash[:order_completed] && order.present?
+    end
+  end
+end

data/app/helpers/spree/store_helper.rb

@@ -0,0 +1,10 @@
+# Methods added to this helper will be available to all templates in the frontend.
+module Spree
+  module StoreHelper
+    def cache_key_for_taxons
+      max_updated_at = @taxons.maximum(:updated_at).to_i
+      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
+      "#{I18n.locale}/taxons/#{parts}"
+    end
+  end
+end

data/app/helpers/spree/taxons_helper.rb

@@ -0,0 +1,20 @@
+module Spree
+  module TaxonsHelper
+    # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
+    # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
+    # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
+    def taxon_preview(taxon, max=4)
+      products = taxon.active_products.select("spree_products.*, spree_products_taxons.position").limit(max)
+      if (products.size < max)
+        products_arel = Spree::Product.arel_table
+        taxon.descendants.each do |taxon|
+          to_get = max - products.length
+          products += taxon.active_products.select("spree_products.*, spree_products_taxons.position").
+                      where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
+          break if products.size >= max
+        end
+      end
+      products
+    end
+  end
+end

data/app/models/spree/frontend_configuration.rb

@@ -0,0 +1,5 @@
+module Spree
+  class FrontendConfiguration < Preferences::Configuration
+    preference :locale, :string, default: Rails.application.config.i18n.default_locale
+  end
+end

data/app/views/kaminari/twitter-bootstrap-3/_first_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "First" page
+  - available local variables
+    url:           url to the first page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<% unless current_page.first? %>
+  <li class="first">
+    <%= link_to_unless current_page.first?, raw(t 'views.pagination.first'), url, :remote => remote %>
+  </li>
+<% end %>

data/app/views/kaminari/twitter-bootstrap-3/_gap.html.erb

@@ -0,0 +1,8 @@
+<%# Non-link tag that stands for skipped pages...
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<li class="page gap disabled"><a href="#" onclick="return false;"><%= raw(t 'views.pagination.truncate') %></a></li>