spree_frontend 2.0.0.rc1

data/app/assets/stylesheets/store/spree_frontend.css

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

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,166 @@
+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
+    ssl_required
+
+    before_filter :load_order
+
+    before_filter :ensure_order_not_completed
+    before_filter :ensure_checkout_allowed
+    before_filter :ensure_sufficient_stock_lines
+    before_filter :ensure_valid_state
+
+    before_filter :associate_user
+    before_filter :check_authorization
+
+    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_attributes(object_params)
+        fire_event('spree.checkout.update')
+        return if after_update_attributes
+
+        unless @order.next
+          flash[:error] = Spree.t(:payment_processing_failed)
+          redirect_to checkout_state_path(@order.state) and return
+        end
+
+        if @order.completed?
+          session[:order_id] = nil
+          flash.notice = Spree.t(:order_processed_successfully)
+          flash[:commerce_tracking] = "nothing special"
+          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
+      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
+
+        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
+        setup_for_current_state
+      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
+
+      # For payment step, filter order parameters to produce the expected nested
+      # attributes for a single payment and its source, discarding attributes
+      # for payment methods other than the one selected
+      def object_params
+        # respond_to check is necessary due to issue described in #2910
+        if @order.has_checkout_step?("payment") && @order.payment?
+          if params[:payment_source].present?
+            source_params = params.delete(:payment_source)[params[:order][:payments_attributes].first[:payment_method_id].underscore]
+
+            if source_params
+              params[:order][:payments_attributes].first[:source_attributes] = source_params
+            end
+          end
+
+          if (params[:order][:payments_attributes])
+            params[:order][:payments_attributes].first[:amount] = @order.total
+          end
+        end
+        params[: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.bill_address ||= Address.default
+        @order.ship_address ||= Address.default
+      end
+
+      def before_delivery
+        return if params[:order].present?
+
+        @order.create_proposed_shipments
+
+        packages = @order.shipments.map { |s| s.to_package }
+        @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+      end
+
+      def before_payment
+        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
+
+      def rescue_from_spree_gateway_error
+        flash[:error] = Spree.t(:spree_gateway_error_flash_for_checkout)
+        render :edit
+      end
+
+      def check_authorization
+        authorize!(:edit, current_order, session[:access_token])
+      end
+
+      def after_update_attributes
+        coupon_result = Spree::Promo::CouponApplicator.new(@order).apply
+        if coupon_result[:coupon_applied?]
+          flash[:success] = coupon_result[:success] if coupon_result[:success].present?
+          return false
+        else
+          flash[:error] = coupon_result[:error]
+          respond_with(@order) { |format| format.html { render :edit } }
+          return true
+        end
+      end
+  end
+end

data/app/controllers/spree/content_controller.rb

@@ -0,0 +1,29 @@
+module Spree
+  class ContentController < Spree::StoreController
+    # Don't serve local files or static assets
+    before_filter { render_404 if params[:path] =~ /(\.|\\)/ }
+    after_filter :fire_visited_path, :only => :show
+    after_filter :fire_visited_action, :except => :show
+
+    rescue_from ActionView::MissingTemplate, :with => :render_404
+    caches_page :show, :index, :if => Proc.new { Spree::Config[:cache_static_content] }
+
+    respond_to :html
+
+    def show
+      render :action => params[:path]
+    end
+
+    def cvv
+      render :layout => false
+    end
+
+    def fire_visited_path
+      fire_event('spree.content.visited', :path => "content/#{params[:path]}")
+    end
+
+    def fire_visited_action
+      fire_event('spree.content.visited', :path => "content/#{params[:action]}")
+    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 = Spree::Config.searcher_class.new(params)
+      @searcher.current_user = try_spree_current_user
+      @searcher.current_currency = current_currency
+      @products = @searcher.retrieve_products
+    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,100 @@
+module Spree
+  class OrdersController < Spree::StoreController
+    ssl_required :show
+
+    before_filter :check_authorization
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/products', 'spree/orders'
+
+    respond_to :html
+
+    def show
+      @order = Order.find_by_number!(params[:id])
+    end
+
+    def update
+      @order = current_order
+      unless @order
+        flash[:error] = Spree.t(:order_not_found)
+        redirect_to root_path and return
+      end
+
+      if @order.update_attributes(params[:order])
+        return if after_update_attributes
+        @order.line_items = @order.line_items.select {|li| li.quantity > 0 }
+        fire_event('spree.order.contents_changed')
+        respond_with(@order) do |format|
+          format.html do
+            if params.has_key?(:checkout)
+              @order.next_transition.run_callbacks 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(true)
+      associate_user
+    end
+
+    # Adds a new item to the order (creating a new order if none already exists)
+    def populate
+      populator = Spree::OrderPopulator.new(current_order(true), current_currency)
+      if populator.populate(params.slice(:products, :variants, :quantity))
+        fire_event('spree.cart.add')
+        fire_event('spree.order.contents_changed')
+        respond_with(@order) do |format|
+          format.html { redirect_to cart_path }
+        end
+      else
+        flash[:error] = populator.errors.full_messages.join(" ")
+        redirect_to :back
+      end
+    end
+
+    def empty
+      if @order = current_order
+        @order.empty!
+      end
+
+      redirect_to spree.cart_path
+    end
+
+    def accurate_title
+      @order && @order.completed? ? "#{Spree.t(:order)} #{@order.number}" : Spree.t(:shopping_cart)
+    end
+
+    def check_authorization
+      session[:access_token] ||= params[:token]
+      order = Spree::Order.find_by_number(params[:id]) || current_order
+
+      if order
+        authorize! :edit, order, session[:access_token]
+      else
+        authorize! :create, Spree::Order
+      end
+    end
+
+    private
+
+    def after_update_attributes
+      coupon_result = Spree::Promo::CouponApplicator.new(@order).apply
+      if coupon_result[:coupon_applied?]
+        flash[:success] = coupon_result[:success] if coupon_result[:success].present?
+        return false
+      else
+        flash[:error] = coupon_result[:error]
+        respond_with(@order) { |format| format.html { render :edit } }
+        return true
+      end
+    end
+  end
+end

data/app/controllers/spree/products_controller.rb

@@ -0,0 +1,50 @@
+module Spree
+  class ProductsController < Spree::StoreController
+    before_filter :load_product, :only => :show
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/taxons'
+
+    respond_to :html
+
+    def index
+      @searcher = Config.searcher_class.new(params)
+      @searcher.current_user = try_spree_current_user
+      @searcher.current_currency = current_currency
+      @products = @searcher.retrieve_products
+    end
+
+    def show
+      return unless @product
+
+      @variants = @product.variants_including_master.active(current_currency).includes([:option_values, :images])
+      @product_properties = @product.product_properties.includes(:property)
+
+      referer = request.env['HTTP_REFERER']
+      if referer
+        begin
+          referer_path = URI.parse(request.env['HTTP_REFERER']).path
+          # Fix for #2249
+        rescue URI::InvalidURIError
+          # Do nothing
+        else
+          if referer_path && referer_path.match(/\/t\/(.*)/)
+            @taxon = Taxon.find_by_permalink($1)
+          end
+        end
+      end
+    end
+
+    private
+      def accurate_title
+        @product ? @product.name : super
+      end
+
+      def load_product
+        if try_spree_current_user.try(:has_spree_role?, "admin")
+          @product = Product.find_by_permalink!(params[:id])
+        else
+          @product = Product.active(current_currency).find_by_permalink!(params[:id])
+        end
+      end
+  end
+end

data/app/controllers/spree/store_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  class StoreController < Spree::BaseController
+    include Spree::Core::ControllerHelpers::Order
+
+    def unauthorized
+      render 'spree/shared/unauthorized', :layout => Spree::Config[:layout], :status => 401
+    end
+
+    protected
+      # This method is placed here so that the CheckoutController
+      # and OrdersController can both reference it.
+      def apply_coupon_code
+        if @order.coupon_code.present?
+          # check if coupon code is already applied
+          if @order.adjustments.promotion.eligible.detect { |p| p.originator.promotion.code == @order.coupon_code }.present?
+            flash[:notice] = Spree.t(:coupon_code_already_applied)
+            true
+          else
+            event_name = "spree.checkout.coupon_code_added"
+            promotion = Spree::Promotion.where("event_name = ? AND lower(code) = ?", event_name, @order.coupon_code).first
+
+            if promotion.present?
+              if promotion.expired?
+                flash[:error] = Spree.t(:coupon_code_expired)
+                return false
+              end
+
+              if promotion.usage_limit_exceeded?
+                flash[:error] = Spree.t(:coupon_code_max_usage)
+                return false
+              end
+
+              eligible_promos = @order.adjustments.promotion.eligible
+
+              previous_promo = eligible_promos.first
+              fire_event(event_name, :coupon_code => @order.coupon_code)
+              promo = eligible_promos.detect { |p| p.originator.promotion.code == @order.coupon_code }
+              ineligible_promos = @order.adjustments.promotion.where(:eligible => false)
+              ineligible_promo = ineligible_promos.detect { |p| p.originator.promotion.code == @order.coupon_code }
+
+              if promo.present? and promo.eligible?
+                flash[:success] = Spree.t(:coupon_code_applied)
+                true
+              elsif previous_promo.present?
+                flash[:error] = Spree.t(:coupon_code_better_exists)
+                false
+              elsif ineligible_promo.present?
+                flash[:error] = Spree.t(:coupon_code_not_eligible)
+                false
+              else
+                # if the promotion was created after the order
+                flash[:error] = Spree.t(:coupon_code_not_found)
+                false
+              end
+            else
+              flash[:error] = Spree.t(:coupon_code_not_found)
+              false
+            end
+          end
+        else
+          true
+        end
+      end
+
+      def config_locale
+        Spree::Frontend::Config[:locale]
+      end
+  end
+end
+