spree_core 0.70.7 → 1.0.0.rc1

data/app/controllers/spree/admin/tax_settings_controller.rb

@@ -0,0 +1,17 @@
+module Spree
+  module Admin
+    class TaxSettingsController < BaseController
+
+      def update
+        Spree::Config.set(params[:preferences])
+
+        respond_to do |format|
+          format.html {
+            redirect_to admin_tax_settings_path
+          }
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/spree/admin/taxonomies_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Admin
+    class TaxonomiesController < ResourceController
+      respond_to :json, :only => [:get_children]
+
+      def get_children
+        @taxons = Taxon.find(params[:parent_id]).children
+
+        respond_with(@taxons)
+      end
+
+      private
+
+      def location_after_save
+        if @taxonomy.created_at == @taxonomy.updated_at
+          edit_admin_taxonomy_url(@taxonomy)
+        else
+          admin_taxonomies_url
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/taxons_controller.rb

@@ -0,0 +1,155 @@
+module Spree
+  module Admin
+    class TaxonsController < BaseController
+
+      respond_to :html, :json, :js
+
+      def create
+        @taxonomy = Taxonomy.find(params[:taxonomy_id])
+        @taxon = @taxonomy.taxons.build(params[:taxon])
+        if @taxon.save
+          respond_with(@taxon) do |format|
+            format.json {render :json => @taxon.to_json }
+          end
+        else
+          flash[:error] = t('errors.messages.could_not_create_taxon')
+          respond_with(@taxon) do |format|
+            format.html { redirect_to @taxonomy ? edit_admin_taxonomy_url(@taxonomy) : admin_taxonomies_url }
+          end
+        end
+      end
+
+      def edit
+        @taxonomy = Taxonomy.find(params[:taxonomy_id])
+        @taxon = @taxonomy.taxons.find(params[:id])
+        @permalink_part = @taxon.permalink.split("/").last
+
+        respond_with(:admin, @taxon) 
+      end
+
+      def update
+        @taxonomy = Taxonomy.find(params[:taxonomy_id])
+        @taxon = @taxonomy.taxons.find(params[:id])
+        parent_id = params[:taxon][:parent_id]
+        new_position = params[:taxon][:position]
+
+        if parent_id || new_position #taxon is being moved
+          new_parent = parent_id.nil? ? @taxon.parent : Taxon.find(parent_id.to_i)
+          new_position = new_position.nil? ? -1 : new_position.to_i
+
+          # Bellow is a very complicated way of finding where in nested set we
+          # should actually move the taxon to achieve sane results,
+          # JS is giving us the desired position, which was awesome for previous setup,
+          # but now it's quite complicated to find where we should put it as we have
+          # to differenciate between moving to the same branch, up down and into
+          # first position.
+          new_siblings = new_parent.children
+          if new_position <= 0 && new_siblings.empty?
+            @taxon.move_to_child_of(new_parent)
+          elsif new_parent.id != @taxon.parent_id
+            if new_position == 0
+              @taxon.move_to_left_of(new_siblings.first)
+            else
+              @taxon.move_to_right_of(new_siblings[new_position-1])
+            end
+          elsif new_position < new_siblings.index(@taxon)
+            @taxon.move_to_left_of(new_siblings[new_position]) # we move up
+          else
+            @taxon.move_to_right_of(new_siblings[new_position]) # we move down
+          end
+          # Reset legacy position, if any extensions still rely on it
+          new_parent.children.reload.each{|t| t.update_attribute(:position, t.position)}
+      
+          if parent_id
+            @taxon.reload
+            @taxon.set_permalink
+            @taxon.save!
+            @update_children = true
+          end
+        end
+
+        if params.key? "permalink_part"
+          parent_permalink = @taxon.permalink.split("/")[0...-1].join("/")
+          parent_permalink += "/" unless parent_permalink.blank?
+          params[:taxon][:permalink] = parent_permalink + params[:permalink_part]
+        end
+        #check if we need to rename child taxons if parent name or permalink changes
+        @update_children = true if params[:taxon][:name] != @taxon.name || params[:taxon][:permalink] != @taxon.permalink
+
+        if @taxon.update_attributes(params[:taxon])
+          flash.notice = flash_message_for(@taxon, :successfully_updated)
+        end
+
+        #rename child taxons
+        if @update_children
+          @taxon.descendants.each do |taxon|
+            taxon.reload
+            taxon.set_permalink
+            taxon.save!
+          end
+        end
+    
+        respond_with(@taxon) do |format|
+          format.html {redirect_to edit_admin_taxonomy_url(@taxonomy) }
+          format.json {render :json => @taxon.to_json }
+        end
+      end
+
+      def destroy
+        @taxon = Taxon.find(params[:id])
+        @taxon.destroy
+        respond_with(@taxon) { |format| format.json { render :json => '' } }
+      end
+
+      def selected
+        @product = load_product
+        @taxons = @product.taxons
+
+        respond_with(:admin, @taxons)
+      end
+
+      def available
+        @product = load_product
+        @taxons = params[:q].blank? ? [] : Taxon.where('lower(name) LIKE ?', "%#{params[:q].mb_chars.downcase}%")
+        @taxons.delete_if { |taxon| @product.taxons.include?(taxon) }
+
+        respond_with(:admin, @taxons)
+      end
+
+      def remove
+        @product = load_product
+        @taxon = Taxon.find(params[:id])
+        @product.taxons.delete(@taxon)
+        @product.save
+        @taxons = @product.taxons
+
+        respond_with(@taxon) { |format| format.js { render_js_for_destroy } }
+      end
+
+      def select
+        @product = load_product
+        @taxon = Taxon.find(params[:id])
+        @product.taxons << @taxon
+        @product.save
+        @taxons = @product.taxons
+
+        respond_with(:admin, @taxons)
+      end
+
+      def batch_select
+        @product = load_product
+        @taxons = params[:taxon_ids].map{|id| Taxon.find(id)}.compact
+        @product.taxons = @taxons
+        @product.save
+        redirect_to selected_admin_product_taxons_url(@product)
+      end
+
+      private
+
+      def load_product
+        Product.find_by_permalink! params[:product_id]
+      end
+
+    end
+  end
+end

data/app/controllers/spree/admin/trackers_controller.rb

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class TrackersController < ResourceController
+    end
+  end
+end

data/app/controllers/spree/admin/users_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Admin
+    class UsersController < ResourceController
+      # http://spreecommerce.com/blog/2010/11/02/json-hijacking-vulnerability/
+      before_filter :check_json_authenticity, :only => :index
+      before_filter :load_roles, :only => [:edit, :new, :update, :create]
+
+      create.after :save_user_roles
+      update.before :save_user_roles
+
+      def index
+        respond_with(@collection) do |format|
+          format.html
+          format.json { render :json => json_data }
+        end
+      end
+
+      protected
+      def collection
+        return @collection if @collection.present?
+        unless request.xhr?
+          @search = Spree::User.registered.metasearch(params[:search])
+          @collection = @search.relation.page(params[:page]).per(Spree::Config[:admin_products_per_page])
+        else
+          #disabling proper nested include here due to rails 3.1 bug
+          #@collection = User.includes(:bill_address => [:state, :country], :ship_address => [:state, :country]).
+          @collection = Spree::User.includes(:bill_address, :ship_address).
+                            where("spree_users.email #{LIKE} :search
+                                   OR (spree_addresses.firstname #{LIKE} :search AND spree_addresses.id = spree_users.bill_address_id)
+                                   OR (spree_addresses.lastname  #{LIKE} :search AND spree_addresses.id = spree_users.bill_address_id)
+                                   OR (spree_addresses.firstname #{LIKE} :search AND spree_addresses.id = spree_users.ship_address_id)
+                                   OR (spree_addresses.lastname  #{LIKE} :search AND spree_addresses.id = spree_users.ship_address_id)",
+            { :search => "#{params[:q].strip}%" }).
+              limit(params[:limit] || 100)
+          end
+        end
+
+        def save_user_roles
+          return unless params[:user]
+          return unless @user.respond_to?(:roles) # since roles are technically added by the auth module
+          @user.roles.delete_all
+          params[:user][:role] ||= {}
+          Role.all.each { |role|
+            @user.roles << role unless params[:user][:role][role.name].blank?
+          }
+          params[:user].delete(:role)
+        end
+
+      private
+        # Allow different formats of json data to suit different ajax calls
+        def json_data
+          json_format = params[:json_format] or 'default'
+          case json_format
+          when 'basic'
+            collection.map { |u| { 'id' => u.id, 'name' => u.email } }.to_json
+          else
+            address_fields = [:firstname, :lastname, :address1, :address2, :city, :zipcode, :phone, :state_name, :state_id, :country_id]
+            includes = { :only => address_fields , :include => { :state => { :only => :name }, :country => { :only => :name } } }
+
+            collection.to_json(:only => [:id, :email], :include =>
+                               { :bill_address => includes, :ship_address => includes })
+          end
+        end
+
+        def load_roles
+          @roles = Role.all
+        end
+    end
+  end
+end

data/app/controllers/spree/admin/variants_controller.rb

@@ -0,0 +1,77 @@
+module Spree
+  module Admin
+    class VariantsController < ResourceController
+      belongs_to 'spree/product', :find_by => :permalink
+      create.before :create_before
+      new_action.before :new_before
+
+      def index
+        respond_with(collection) do |format|
+          format.html
+          format.json { render :json => json_data }
+        end
+      end
+
+      # override the destory method to set deleted_at value
+      # instead of actually deleting the product.
+      def destroy
+        @variant = Variant.find(params[:id])
+
+        @variant.deleted_at = Time.now()
+        if @variant.save
+          flash.notice = I18n.t('notice_messages.variant_deleted')
+        else
+          flash.notice = I18n.t('notice_messages.variant_not_deleted')
+        end
+
+        respond_with(@variant) do |format|
+          format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+          format.js  { render_js_for_destroy }
+        end
+      end
+
+      def update_positions
+        params[:positions].each do |id, index|
+          Variant.where(:id => id).update_all(:position => index)
+        end
+
+        respond_with(@variant) do |format|
+          format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+          format.js  { render :text => 'Ok' }
+        end
+      end
+
+      protected
+      def create_before
+        option_values = params[:new_variant]
+        option_values.each_value {|id| @object.option_values << OptionValue.find(id)}
+        @object.save
+      end
+
+
+      def new_before
+        @object.attributes = @object.product.master.attributes.except('id', 'created_at', 'deleted_at',
+                                                                      'sku', 'is_master', 'count_on_hand')
+      end
+
+      def collection
+        @deleted = (params.key?(:deleted)  && params[:deleted] == "on") ? "checked" : ""
+
+        if @deleted.blank?
+          @collection ||= super
+        else
+          @collection ||= Variant.where(:product_id => parent.id).deleted
+        end
+        @collection
+      end
+
+      def json_data
+        ( parent.variants.presence || [parent.master] ).map do |v|
+          { :label => v.options_text.presence || v.name, :id => v.id }
+        end
+      end
+
+    end
+  end
+end
+

data/app/controllers/spree/admin/zones_controller.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Admin
+    class ZonesController < ResourceController
+      before_filter :load_data, :except => [:index]
+
+      def new
+        @zone.zone_members.build
+        respond_with(@zone)
+      end
+
+      protected
+
+      def collection
+        params[:search] ||= {}
+        params[:search][:meta_sort] ||= "ascend_by_name"
+        @search = super.metasearch(params[:search])
+        @zones = @search.relation.page(params[:page]).per(Spree::Config[:orders_per_page])
+      end
+
+      def load_data
+        @countries = Country.order(:name)
+        @states = State.order(:name)
+        @zones = Zone.order(:name)
+      end
+    end
+  end
+end

data/app/controllers/spree/base_controller.rb

@@ -1,4 +1,4 @@
-class Spree::BaseController < ActionController::Base
-  include SpreeBase
-  include SpreeRespondWith
+class Spree::BaseController < ApplicationController
+  include Spree::Core::ControllerHelpers
+  include Spree::Core::RespondWith
 end

data/app/controllers/spree/checkout_controller.rb

@@ -0,0 +1,99 @@
+module Spree
+  # Handles checkout logic.  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 < BaseController
+    ssl_required
+
+    before_filter :load_order
+    rescue_from Spree::Core::GatewayError, :with => :rescue_from_spree_gateway_error
+
+    respond_to :html
+
+    # Updates the order and advances to the next state (when possible.)
+    def update
+      if @order.update_attributes(object_params)
+        fire_event('spree.checkout.update')
+
+        if @order.next
+          state_callback(:after)
+        else
+          flash[:error] = t(:payment_processing_failed)
+          respond_with(@order, :location => checkout_state_path(@order.state))
+          return
+        end
+
+        if @order.state == "complete" || @order.completed?
+          flash.notice = t(:order_processed_successfully)
+          flash[:commerce_tracking] = "nothing special"
+          respond_with(@order, :location => completion_route)
+        else
+          respond_with(@order, :location => checkout_state_path(@order.state))
+        end
+      else
+        respond_with(@order) { |format| format.html { render :edit } }
+      end
+    end
+
+    private
+      # Provides a route to redirect after order completion
+      def completion_route
+        order_path(@order)
+      end
+
+      def object_params
+        # 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
+        if @order.payment?
+          if params[:payment_source].present? && source_params = params.delete(:payment_source)[params[:order][:payments_attributes].first[:payment_method_id].underscore]
+            params[:order][:payments_attributes].first[:source_attributes] = source_params
+          end
+          if (params[:order][:payments_attributes])
+            params[:order][:payments_attributes].first[:amount] = @order.total
+          end
+        end
+        params[:order]
+      end
+
+      def load_order
+        @order = current_order
+        redirect_to cart_path and return unless @order and @order.checkout_allowed?
+        raise_insufficient_quantity and return if @order.insufficient_stock_lines.present?
+        redirect_to cart_path and return if @order.completed?
+        @order.state = params[:state] if params[:state]
+        state_callback(:before)
+      end
+
+      def raise_insufficient_quantity
+        flash[:error] = t(:spree_inventory_error_flash_for_insufficient_quantity)
+        redirect_to cart_path
+      end
+
+      def state_callback(before_or_after = :before)
+        method_name = :"#{before_or_after}_#{@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.shipping_method ||= (@order.rate_hash.first && @order.rate_hash.first[:shipping_method])
+      end
+
+      def before_payment
+        current_order.payments.destroy_all if request.put?
+      end
+
+      def after_complete
+        session[:order_id] = nil
+      end
+
+      def rescue_from_spree_gateway_error
+        flash[:error] = t(:spree_gateway_error_flash_for_checkout)
+        render :edit
+      end
+  end
+end