solidus_frontend 1.0.0.pre

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

@@ -0,0 +1,6 @@
+/*
+* This is a manifest file that includes stylesheets for spree_frontend 
+ *= require normalize
+ *= require skeleton
+ *= require spree/frontend/screen
+*/

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,167 @@
+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_filter :load_order
+    around_filter :lock_order
+    before_filter :ensure_valid_state_lock_version, only: [:update]
+    before_filter :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
+
+    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]
+        success = if @order.state == 'confirm'
+          @order.complete
+        else
+          @order.next
+        end
+        if !success
+          flash[:error] = @order.errors.full_messages.join("\n")
+          redirect_to checkout_state_path(@order.state) and 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 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 #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 and 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) and return
+            end
+            @order.increment!(:state_lock_version)
+          end
+        end
+      end
+
+      def set_state_if_present
+        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 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
+        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
+        # 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 { |s| s.to_package }
+        @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+      end
+
+      def before_payment
+        if @order.checkout_steps.include? "delivery"
+          packages = @order.shipments.map { |s| s.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 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
+  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_filter { 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,12 @@
+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
+      @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,115 @@
+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_filter :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_filter :lock_order, only: :update
+    before_filter :apply_coupon_code, only: :update
+    skip_before_filter :verify_authenticity_token, only: [:populate]
+
+    def show
+      @order = Order.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.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
+
+      # 2,147,483,647 is crazy. See issue #2695.
+      if quantity.between?(1, 2_147_483_647)
+        begin
+          order.contents.add(variant, quantity)
+        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
+      cookies.permanent.signed[:guest_token] = params[:token] if params[:token]
+      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
+        @order = current_order
+        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,45 @@
+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
+      @taxonomies = Spree::Taxonomy.includes(root: :children)
+    end
+
+    def show
+      @variants = @product.variants_including_master.active(current_currency).includes([:option_values, :images])
+      @product_properties = @product.product_properties.includes(:property)
+      @taxon = Spree::Taxon.find(params[:taxon_id]) if params[:taxon_id]
+    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.friendly.find(params[:id])
+      end
+
+      def load_taxon
+        @taxon = Spree::Taxon.find(params[:taxon]) if params[:taxon].present?
+      end
+  end
+end

data/app/controllers/spree/store_controller.rb

@@ -0,0 +1,47 @@
+module Spree
+  class StoreController < Spree::BaseController
+    include Spree::Core::ControllerHelpers::Order
+
+    skip_before_action :set_current_order, only: :cart_link
+
+    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
+
+      def lock_order
+        OrderMutex.with_lock!(@order) { yield }
+      rescue Spree::OrderMutex::LockFailed => e
+        flash[:error] = Spree.t(:order_mutex_error)
+        redirect_to spree.cart_path
+      end
+  end
+end
+

data/app/controllers/spree/taxons_controller.rb

@@ -0,0 +1,28 @@
+module Spree
+  class TaxonsController < Spree::StoreController
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/products'
+
+    respond_to :html
+
+    def show
+      @taxon = Taxon.find_by_permalink!(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
+      if @taxon
+        @taxon.seo_title
+      else
+        super
+      end
+    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/spree/address/_form.html.erb

@@ -0,0 +1,75 @@
+<% address_id = address_type.chars.first %>
+<div class="inner" data-hook=<%="#{address_type}_inner" %>>
+  <p class="field" id=<%="#{address_id}firstname" %>>
+    <%= form.label :firstname, Spree.t(:first_name) %><span class="required">*</span><br />
+    <%= form.text_field :firstname, :class => 'required' %>
+  </p>
+  <p class="field" id=<%="#{address_id}lastname" %>>
+    <%= form.label :lastname, Spree.t(:last_name) %><span class="required">*</span><br />
+    <%= form.text_field :lastname, :class => 'required' %>
+  </p>
+  <% if Spree::Config[:company] %>
+    <p class="field" id=<%="#{address_id}company" %>>
+      <%= form.label :company, Spree.t(:company) %><br />
+      <%= form.text_field :company %>
+    </p>
+  <% end %>
+  <p class="field" id=<%="#{address_id}address1" %>>
+    <%= form.label :address1, Spree.t(:street_address) %><span class="required">*</span><br />
+    <%= form.text_field :address1, :class => 'required' %>
+  </p>
+  <p class="field" id=<%="#{address_id}address2" %>>
+    <%= form.label :address2, Spree.t(:street_address_2) %><br />
+    <%= form.text_field :address2 %>
+  </p>
+  <p class="field" id=<%="#{address_id}city" %>>
+    <%= form.label :city, Spree.t(:city) %><span class="required">*</span><br />
+    <%= form.text_field :city, :class => 'required' %>
+  </p>
+  <p class="field" id=<%="#{address_id}country" %>>
+    <%= form.label :country_id, Spree.t(:country) %><span class="required">*</span><br />
+    <span id=<%="#{address_id}country-selection" %>>
+      <%= form.collection_select :country_id, available_countries, :id, :name, {}, {:class => 'required'} %>
+    </span>
+  </p>
+
+  <% if Spree::Config[:address_requires_state] %>
+    <p class="field" id=<%="#{address_id}state" %>>
+      <% have_states = !address.country.states.empty? %>
+      <%= form.label :state, Spree.t(:state) %><span class='required' id=<%="#{address_id}state-required"%>>*</span><br/>
+
+      <% state_elements = [
+         form.collection_select(:state_id, address.country.states,
+                            :id, :name,
+                            {:include_blank => true},
+                            {:class => have_states ? 'required' : 'hidden',
+                            :disabled => !have_states}) +
+         form.text_field(:state_name,
+                            :class => !have_states ? 'required' : 'hidden',
+                            :disabled => have_states)
+         ].join.gsub('"', "'").gsub("\n", "")
+      %>
+      <%= javascript_tag do -%>
+        $('#<%="#{address_id}state" %>').append("<%== state_elements %>");
+      <% end %>
+    </p>
+      <noscript>
+        <%= form.text_field :state_name, :class => 'required' %>
+      </noscript>
+  <% end %>
+
+  <p class="field" id=<%="#{address_id}zipcode" %>>
+    <%= form.label :zipcode, Spree.t(:zip) %><% if address.require_zipcode? %><span class="required">*</span><br /><% end %>
+    <%= form.text_field :zipcode, :class => "#{'required' if address.require_zipcode?}" %>
+  </p>
+  <p class="field" id=<%="#{address_id}phone" %>>
+    <%= form.label :phone, Spree.t(:phone) %><% if address.require_phone? %><span class="required">*</span><br /><% end %>
+    <%= form.phone_field :phone, :class => "#{'required' if address.require_phone?}" %>
+  </p>
+  <% if Spree::Config[:alternative_shipping_phone] %>
+    <p class="field" id=<%="#{address_id}altphone" %>>
+      <%= form.label :alternative_phone, Spree.t(:alternative_phone) %><br />
+      <%= form.phone_field :alternative_phone %>
+    </p>
+  <% end %>
+</div>

data/app/views/spree/checkout/_address.html.erb

@@ -0,0 +1,33 @@
+<div class="columns alpha six" data-hook="billing_fieldset_wrapper">
+  <fieldset id="billing" data-hook>
+    <%= form.fields_for :bill_address do |bill_form| %>
+      <legend align="center"><%= Spree.t(:billing_address) %></legend>
+      <%= render :partial => 'spree/address/form', :locals => { :form => bill_form, :address_type => 'billing', :address => @order.bill_address } %>
+    <% end %>
+  </fieldset>
+</div>
+
+<div class="columns omega six" data-hook="shipping_fieldset_wrapper">
+  <fieldset id="shipping" data-hook>
+    <%= form.fields_for :ship_address do |ship_form| %>
+      <legend align="center"><%= Spree.t(:shipping_address) %></legend>
+      <p class="field checkbox" data-hook="use_billing">
+        <%= check_box_tag 'order[use_billing]', '1', @order.shipping_eq_billing_address? %>
+        <%= label_tag :order_use_billing, Spree.t(:use_billing_address), :id => 'use_billing' %>
+      </p>
+      <%= render :partial => 'spree/address/form', :locals => { :form => ship_form, :address_type => 'shipping', :address => @order.ship_address } %>
+    <% end %>
+  </fieldset>
+</div>
+<hr class="clear" />
+
+<div class="form-buttons" data-hook="buttons">
+  <%= submit_tag Spree.t(:save_and_continue), :class => 'continue button primary' %>
+  <% if try_spree_current_user %>
+    <span data-hook="save_user_address">
+      &nbsp; &nbsp;
+      <%= check_box_tag 'save_user_address', '1', try_spree_current_user.respond_to?(:persist_order_address) %>
+      <%= label_tag :save_user_address, Spree.t(:save_my_address) %>
+    </span>
+  <% end %>
+</div>

data/app/views/spree/checkout/_confirm.html.erb

@@ -0,0 +1,12 @@
+<fieldset id="order_details" data-hook>
+  <div class="clear"></div>
+  <legend align="center"><%= Spree.t(:confirm) %></legend>
+  <%= render :partial => 'spree/shared/order_details', :locals => { :order => @order } %>
+</fieldset>
+
+<br />
+
+<div class="form-buttons" data-hook="buttons">
+  <%= submit_tag Spree.t(:place_order), :class => 'continue button primary' %>
+  <script>Spree.disableSaveOnClick();</script>
+</div>