apispree_core 0.0.0

data/app/controllers/admin/shipping_categories_controller.rb

@@ -0,0 +1,2 @@
+class Admin::ShippingCategoriesController < Admin::ResourceController
+end

data/app/controllers/admin/shipping_methods_controller.rb

@@ -0,0 +1,14 @@
+class Admin::ShippingMethodsController < Admin::ResourceController
+  before_filter :load_data, :except => [:index]
+
+  private
+  
+  def location_after_save
+    edit_admin_shipping_method_path(@shipping_method)
+  end
+
+  def load_data
+    @available_zones = Zone.order(:name)
+    @calculators = ShippingMethod.calculators.sort_by(&:name)
+  end
+end

data/app/controllers/admin/states_controller.rb

@@ -0,0 +1,25 @@
+class Admin::StatesController < Admin::ResourceController
+  belongs_to :country
+  before_filter :load_data
+
+  def index
+    respond_with(@collection) do |format|
+      format.html
+      format.js  { render :partial => 'state_list.html.erb' }
+    end
+  end
+
+  protected
+
+  def location_after_save
+    admin_country_states_url(@country)
+  end
+
+  def collection
+    super.order(:name)
+  end
+
+  def load_data
+    @countries = Country.order(:name)
+  end
+end

data/app/controllers/admin/tax_categories_controller.rb

@@ -0,0 +1,2 @@
+class Admin::TaxCategoriesController < Admin::ResourceController
+end

data/app/controllers/admin/tax_rates_controller.rb

@@ -0,0 +1,22 @@
+class Admin::TaxRatesController < Admin::ResourceController
+  before_filter :load_data
+
+  update.after :update_after
+  create.after :create_after
+
+  private
+  
+  def load_data
+    @available_zones = Zone.order(:name)
+    @available_categories = TaxCategory.order(:name)
+    @calculators = TaxRate.calculators
+  end
+
+  def update_after
+    Rails.cache.delete('vat_rates')
+  end
+
+  def create_after
+    Rails.cache.delete('vat_rates')
+  end
+end

data/app/controllers/admin/tax_settings_controller.rb

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

data/app/controllers/admin/taxonomies_controller.rb

@@ -0,0 +1,20 @@
+class Admin::TaxonomiesController < Admin::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

data/app/controllers/admin/taxons_controller.rb

@@ -0,0 +1,161 @@
+class Admin::TaxonsController < Admin::BaseController
+  include Railslove::Plugins::FindByParam::SingletonMethods
+
+  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] = I18n.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
+  
+
+  def update
+    update_before
+    update_after
+    respond_with(@taxon) do |format|
+      format.html { redirect_to edit_admin_taxonomy_url(@taxonomy) }
+      format.json { render :json => @taxon.to_json }
+    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

data/app/controllers/admin/trackers_controller.rb

@@ -0,0 +1,2 @@
+class Admin::TrackersController < Admin::ResourceController
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,65 @@
+class Admin::UsersController < Admin::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 = User.registered.metasearch(params[:search])
+      @collection = @search.paginate(:per_page => Spree::Config[:admin_products_per_page], :page => params[:page])
+    else
+      @collection = User.includes(:bill_address => [:state, :country], :ship_address => [:state, :country]).
+                        where("users.email #{LIKE} :search
+                               OR addresses.firstname #{LIKE} :search
+                               OR addresses.lastname #{LIKE} :search
+                               OR ship_addresses_users.firstname #{LIKE} :search
+                               OR ship_addresses_users.lastname #{LIKE} :search",
+                               {: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
+      collection.to_json(:include =>
+        {:bill_address => {:include => [:state, :country]},
+        :ship_address => {:include => [:state, :country]}})
+    end
+  end
+
+  def load_roles
+    @roles = Role.all
+  end
+
+end

data/app/controllers/admin/variants_controller.rb

@@ -0,0 +1,51 @@
+class Admin::VariantsController < Admin::ResourceController
+  belongs_to :product, :find_by => :permalink
+  create.before :create_before
+
+  # 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.update_all(['position=?', index], ['id=?', id])
+    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 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
+end

data/app/controllers/admin/zones_controller.rb

@@ -0,0 +1,23 @@
+class Admin::ZonesController < Admin::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.paginate(:per_page => Spree::Config[:orders_per_page], :page => params[:page])
+  end
+
+  def load_data
+    @countries = Country.order(:name)
+    @states = State.order(:name)
+    @zones = Zone.order(:name)
+  end
+end

data/app/controllers/checkout_controller.rb

@@ -0,0 +1,97 @@
+# 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 < Spree::BaseController
+  ssl_required
+
+  before_filter :load_order
+  rescue_from Spree::GatewayError, :with => :rescue_from_spree_gateway_error
+
+  respond_to :json
+
+  # Updates the order and advances to the next state (when possible.)
+  def update
+    if @order.update_attributes(object_params)
+      if @order.next
+        state_callback(:after)
+      else
+        flash[:error] = I18n.t(:payment_processing_failed)
+        #respond_with(@order, :location => checkout_state_path(@order.state))
+        render :json => @order.to_json, :status => 201
+        return
+      end
+
+      if @order.state == "complete" || @order.completed?
+        flash[:notice] = I18n.t(:order_processed_successfully)
+        flash[:commerce_tracking] = "nothing special"
+        #respond_with(@order, :location => completion_route)
+        render :json => @order.to_json, :status => 201,:location => completion_route
+      else
+        #respond_with(@order, :location => checkout_state_path(@order.state))
+        render :json => @order.to_json, :status => 201,:location=>checkout_state_path(@order.state)
+      end
+    else
+      #respond_with(@order) { |format| format.html { render :edit } }
+      render :json => @order.to_json, :status => 201
+    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?
+    redirect_to cart_path and return if @order.completed?
+    @order.state = params[:state] if params[:state]
+    state_callback(:before)
+  end
+
+  def state_callback(before_or_after = :before)
+    method_name = :"#{before_or_after}_#{@order.state}"
+    p method_name
+    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