spree_core 1.3.5 → 2.0.0.rc1

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

@@ -1,17 +0,0 @@
-# this clas was inspired (heavily) from the mephisto admin architecture
-module Spree
-  module Admin
-    class OverviewController < Spree::Admin::BaseController
-      #todo, add rss feed of information that is happening
-
-      def index
-        @users = User.all
-        #@users = User.find_with_deleted(:all, :order => 'updated_at desc')
-    #  going to list today's orders, yesterday's orders, older orders
-    # have a filter / search at the top
-        # @orders, @
-      end
-
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-module Spree
-  module Admin
-    class PaymentMethodsController < ResourceController
-      skip_before_filter :load_resource, :only => [:create]
-      before_filter :load_data
-
-      respond_to :html
-
-      def create
-        @payment_method = params[:payment_method].delete(:type).constantize.new(params[:payment_method])
-        @object = @payment_method
-        invoke_callbacks(:create, :before)
-        if @payment_method.save
-          invoke_callbacks(:create, :after)
-          flash[:success] = I18n.t(:successfully_created, :resource => I18n.t(:payment_method))
-          respond_with(@payment_method, :location => edit_admin_payment_method_path(@payment_method))
-        else
-          invoke_callbacks(:create, :fails)
-          respond_with(@payment_method)
-        end
-      end
-
-      def update
-        invoke_callbacks(:update, :before)
-        payment_method_type = params[:payment_method].delete(:type)
-        if @payment_method['type'].to_s != payment_method_type
-          @payment_method.update_column(:type, payment_method_type)
-          @payment_method = PaymentMethod.find(params[:id])
-        end
-
-        payment_method_params = params[ActiveModel::Naming.param_key(@payment_method)] || {}
-        attributes = params[:payment_method].merge(payment_method_params)
-        attributes.each do |k,v|
-          if k.include?("password") && attributes[k].blank?
-            attributes.delete(k)
-          end
-        end
-
-        if @payment_method.update_attributes(attributes)
-          invoke_callbacks(:update, :after)
-          flash[:success] = I18n.t(:successfully_updated, :resource => I18n.t(:payment_method))
-          respond_with(@payment_method, :location => edit_admin_payment_method_path(@payment_method))
-        else
-          invoke_callbacks(:update, :fails)
-          respond_with(@payment_method)
-        end
-      end
-
-      private
-
-      def load_data
-        @providers = Gateway.providers.sort{|p1, p2| p1.name <=> p2.name }
-      end
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-module Spree
-  module Admin
-    class PaymentsController < Spree::Admin::BaseController
-      before_filter :load_order, :only => [:create, :new, :index, :fire]
-      before_filter :load_payment, :except => [:create, :new, :index]
-      before_filter :load_data
-
-      respond_to :html
-
-      def index
-        @payments = @order.payments
-
-        respond_with(@payments)
-      end
-
-      def new
-        @payment = @order.payments.build
-        respond_with(@payment)
-      end
-
-      def create
-        @payment = @order.payments.build(object_params)
-        if @payment.payment_method.is_a?(Spree::Gateway) && @payment.payment_method.payment_profiles_supported? && params[:card].present? and params[:card] != 'new'
-          @payment.source = CreditCard.find_by_id(params[:card])
-        end
-
-        begin
-          unless @payment.save
-            respond_with(@payment) { |format| format.html { redirect_to admin_order_payments_path(@order) } }
-            return
-          end
-
-          if @order.completed?
-            @payment.process!
-            flash[:success] = flash_message_for(@payment, :successfully_created)
-
-            respond_with(@payment) { |format| format.html { redirect_to admin_order_payments_path(@order) } }
-          else
-            #This is the first payment (admin created order)
-            until @order.completed?
-              @order.next!
-            end
-            flash[:success] = t(:new_order_completed)
-            respond_with(@payment) { |format| format.html { redirect_to admin_order_url(@order) } }
-          end
-
-        rescue Spree::Core::GatewayError => e
-          flash[:error] = "#{e.message}"
-          respond_with(@payment) { |format| format.html { redirect_to new_admin_order_payment_path(@order) } }
-        end
-      end
-
-      def fire
-        return unless event = params[:e] and @payment.payment_source
-
-        # Because we have a transition method also called void, we do this to avoid conflicts.
-        event = "void_transaction" if event == "void"
-        if @payment.send("#{event}!")
-          flash[:success] = t(:payment_updated)
-        else
-          flash[:error] = t(:cannot_perform_operation)
-        end
-      rescue Spree::Core::GatewayError => ge
-        flash[:error] = "#{ge.message}"
-      ensure
-        respond_with(@payment) { |format| format.html { redirect_to admin_order_payments_path(@order) } }
-      end
-
-      private
-
-      def object_params
-        if params[:payment] and params[:payment_source] and source_params = params.delete(:payment_source)[params[:payment][:payment_method_id]]
-          params[:payment][:source_attributes] = source_params
-        end
-        params[:payment]
-      end
-
-      def load_data
-        @amount = params[:amount] || load_order.total
-        @payment_methods = PaymentMethod.available(:back_end)
-        if @payment and @payment.payment_method
-          @payment_method = @payment.payment_method
-        else
-          @payment_method = @payment_methods.first
-        end
-        @previous_cards = @order.credit_cards.with_payment_profile
-      end
-
-      def load_order
-        @order = Order.find_by_number!(params[:order_id])
-        authorize! action, @order
-      end
-
-      def load_payment
-        @payment = Payment.find(params[:id])
-      end
-
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module Spree
-  module Admin
-    class ProductPropertiesController < ResourceController
-      belongs_to 'spree/product', :find_by => :permalink
-      before_filter :find_properties
-      before_filter :setup_property, :only => [:index]
-
-      # We use a "custom" finder in destroy
-      # Because the request is scoped without a product
-      # on account of the request coming from the "link_to_remove_fields"
-      # helper on the admin/product_properties view
-      skip_before_filter :load_resource, :only => [:destroy]
-
-      def destroy
-        product_property = Spree::ProductProperty.find(params[:id])
-        product_property.destroy
-        render :text => nil
-      end
-
-      private
-        def find_properties
-          @properties = Spree::Property.pluck(:name)
-        end
-
-        def setup_property
-          @product.product_properties.build
-        end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-module Spree
-  module Admin
-    class ProductsController < ResourceController
-      helper 'spree/products'
-
-#      before_filter :check_json_authenticity, :only => :index
-      before_filter :load_data, :except => :index
-      create.before :create_before
-      update.before :update_before
-
-      def show
-        session[:return_to] ||= request.referer
-        redirect_to( :action => :edit )
-      end
-
-      def index
-        session[:return_to] = request.url
-        respond_with(@collection)
-      end
-
-      def search
-        if params[:ids]
-          @products = Spree::Product.where(:id => params[:ids].split(","))
-        else
-          search_params = { :name_cont => params[:q], :sku_cont => params[:q] }
-          @products = Spree::Product.ransack(search_params.merge(:m => 'or')).result
-        end
-      end
-
-      def update
-        if params[:product][:taxon_ids].present?
-          params[:product][:taxon_ids] = params[:product][:taxon_ids].split(',')
-        end
-        super
-      end
-
-      def destroy
-        @product = Product.find_by_permalink!(params[:id])
-        @product.delete
-
-        flash.notice = I18n.t('notice_messages.product_deleted')
-
-        respond_with(@product) do |format|
-          format.html { redirect_to collection_url }
-          format.js  { render_js_for_destroy }
-        end
-      end
-
-      def clone
-        @new = @product.duplicate
-
-        if @new.save
-          flash.notice = I18n.t('notice_messages.product_cloned')
-        else
-          flash.notice = I18n.t('notice_messages.product_not_cloned')
-        end
-
-        respond_with(@new) { |format| format.html { redirect_to edit_admin_product_url(@new) } }
-      end
-
-      protected
-
-        def find_resource
-          Product.find_by_permalink!(params[:id])
-        end
-
-        def location_after_save
-          edit_admin_product_url(@product)
-        end
-
-        def load_data
-          @taxons = Taxon.order(:name)
-          @option_types = OptionType.order(:name)
-          @tax_categories = TaxCategory.order(:name)
-          @shipping_categories = ShippingCategory.order(:name)
-        end
-
-        def collection
-          return @collection if @collection.present?
-          params[:q] ||= {}
-          params[:q][:deleted_at_null] ||= "1"
-
-          params[:q][:s] ||= "name asc"
-
-          @search = super.ransack(params[:q])
-          @collection = @search.result.
-            group_by_products_id.
-            includes(product_includes).
-            page(params[:page]).
-            per(Spree::Config[:admin_products_per_page])
-
-          if params[:q][:s].include?("master_default_price_amount")
-            # PostgreSQL compatibility
-            @collection = @collection.group("spree_prices.amount")
-          end
-          @collection
-        end
-
-        def create_before
-          return if params[:product][:prototype_id].blank?
-          @prototype = Spree::Prototype.find(params[:product][:prototype_id])
-        end
-
-        def update_before
-          # note: we only reset the product properties if we're receiving a post from the form on that tab
-          return unless params[:clear_product_properties]
-          params[:product] ||= {}
-        end
-
-        def product_includes
-         [{:variants => [:images, {:option_values => :option_type}]}, {:master => [:images, :default_price]}]
-        end
-
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Spree
-  module Admin
-    class PropertiesController < ResourceController
-
-      # Looks like this action is unused
-      def filtered
-        @properties = Property.where('lower(name) LIKE ?', "%#{params[:q].mb_chars.downcase}%").order(:name)
-        respond_with(@properties) do |format|
-          format.html { render :template => "spree/admin/properties/filtered", :formats => [:html], :handlers => [:erb], :layout => false }
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Spree
-  module Admin
-    class PrototypesController < ResourceController
-      def show
-        if request.xhr?
-          render :layout => false
-        else
-          redirect_to admin_prototypes_path
-        end
-      end
-
-      def available
-        @prototypes = Prototype.order('name asc')
-        respond_with(@prototypes) do |format|
-          format.html { render :layout => !request.xhr? }
-          format.js
-        end
-      end
-
-      def select
-        @prototype ||= Prototype.find(params[:id])
-        @prototype_properties = @prototype.properties
-
-        respond_with(@prototypes)
-      end
-
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Spree
-  module Admin
-    class ReportsController < Spree::Admin::BaseController
-      respond_to :html
-
-      AVAILABLE_REPORTS = {
-        :sales_total => { :name => I18n.t(:sales_total), :description => I18n.t(:sales_total_description) }
-      }
-
-      def index
-        @reports = AVAILABLE_REPORTS
-        respond_with(@reports)
-      end
-
-      def sales_total
-        params[:q] = {} unless params[:q]
-
-        if params[:q][:created_at_gt].blank?
-          params[:q][:created_at_gt] = Time.zone.now.beginning_of_month
-        else
-          params[:q][:created_at_gt] = Time.zone.parse(params[:q][:created_at_gt]).beginning_of_day rescue Time.zone.now.beginning_of_month
-        end
-
-        if params[:q] && !params[:q][:created_at_lt].blank?
-          params[:q][:created_at_lt] = Time.zone.parse(params[:q][:created_at_lt]).end_of_day rescue ""
-        end
-
-        if params[:q].delete(:completed_at_not_null) == "1"
-          params[:q][:completed_at_not_null] = true
-        else
-          params[:q][:completed_at_not_null] = false
-        end
-
-        params[:q][:s] ||= "created_at desc"
-
-        @search = Order.complete.ransack(params[:q])
-        @orders = @search.result
-
-        @totals = {}
-        @orders.each do |order|
-          @totals[order.currency] = { :item_total => ::Money.new(0, order.currency), :adjustment_total => ::Money.new(0, order.currency), :sales_total => ::Money.new(0, order.currency) } unless @totals[order.currency]
-          @totals[order.currency][:item_total] += order.display_item_total.money
-          @totals[order.currency][:adjustment_total] += order.display_adjustment_total.money
-          @totals[order.currency][:sales_total] += order.display_total.money
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,265 +0,0 @@
-require 'spree/core/action_callbacks'
-
-class Spree::Admin::ResourceController < Spree::Admin::BaseController
-  helper_method :new_object_url, :edit_object_url, :object_url, :collection_url
-  before_filter :load_resource, :except => [:update_positions]
-  rescue_from ActiveRecord::RecordNotFound, :with => :resource_not_found
-
-  respond_to :html
-  respond_to :js, :except => [:show, :index]
-
-  def new
-    invoke_callbacks(:new_action, :before)
-    respond_with(@object) do |format|
-      format.html { render :layout => !request.xhr? }
-      format.js   { render :layout => false }
-    end
-  end
-
-  def edit
-    respond_with(@object) do |format|
-      format.html { render :layout => !request.xhr? }
-      format.js   { render :layout => false }
-    end
-  end
-
-  def update
-    invoke_callbacks(:update, :before)
-    if @object.update_attributes(params[object_name])
-      invoke_callbacks(:update, :after)
-      flash[:success] = flash_message_for(@object, :successfully_updated)
-      respond_with(@object) do |format|
-        format.html { redirect_to location_after_save }
-        format.js   { render :layout => false }
-      end
-    else
-      invoke_callbacks(:update, :fails)
-      respond_with(@object)
-    end
-  end
-
-  def create
-    invoke_callbacks(:create, :before)
-    @object.attributes = params[object_name]
-    if @object.save
-      invoke_callbacks(:create, :after)
-      flash[:success] = flash_message_for(@object, :successfully_created)
-      respond_with(@object) do |format|
-        format.html { redirect_to location_after_save }
-        format.js   { render :layout => false }
-      end
-    else
-      invoke_callbacks(:create, :fails)
-      respond_with(@object)
-    end
-  end
-
-  def update_positions
-    params[:positions].each do |id, index|
-      model_class.where(:id => id).update_all(:position => index)
-    end
-
-    respond_to do |format|
-      format.js  { render :text => 'Ok' }
-    end
-  end
-
-  def destroy
-    invoke_callbacks(:destroy, :before)
-    if @object.destroy
-      invoke_callbacks(:destroy, :after)
-      flash[:success] = flash_message_for(@object, :successfully_removed)
-      respond_with(@object) do |format|
-        format.html { redirect_to location_after_destroy }
-        format.js   { render :partial => "spree/admin/shared/destroy" }
-      end
-    else
-      invoke_callbacks(:destroy, :fails)
-      respond_with(@object) do |format|
-        format.html { redirect_to location_after_destroy }
-      end
-    end
-  end
-
-  protected
-
-    def resource_not_found
-      flash[:error] = flash_message_for(model_class.new, :not_found)
-      redirect_to collection_url
-    end
-
-    class << self
-      attr_accessor :parent_data
-      attr_accessor :callbacks
-
-      def belongs_to(model_name, options = {})
-        @parent_data ||= {}
-        @parent_data[:model_name] = model_name
-        @parent_data[:model_class] = model_name.to_s.classify.constantize
-        @parent_data[:find_by] = options[:find_by] || :id
-      end
-
-      def new_action
-        @callbacks ||= {}
-        @callbacks[:new_action] ||= Spree::ActionCallbacks.new
-      end
-
-      def create
-        @callbacks ||= {}
-        @callbacks[:create] ||= Spree::ActionCallbacks.new
-      end
-
-      def update
-        @callbacks ||= {}
-        @callbacks[:update] ||= Spree::ActionCallbacks.new
-      end
-
-      def destroy
-        @callbacks ||= {}
-        @callbacks[:destroy] ||= Spree::ActionCallbacks.new
-      end
-    end
-
-    def model_class
-      "Spree::#{controller_name.classify}".constantize
-    end
-
-    def model_name
-      parent_data[:model_name].gsub('spree/', '')
-    end
-
-    def object_name
-      controller_name.singularize
-    end
-
-    def load_resource
-      if member_action?
-        @object ||= load_resource_instance
-
-        # call authorize! a third time (called twice already in Admin::BaseController)
-        # this time we pass the actual instance so fine-grained abilities can control
-        # access to individual records, not just entire models.
-        authorize! action, @object
-
-        instance_variable_set("@#{object_name}", @object)
-      else
-        @collection ||= collection
-
-        # note: we don't call authorize here as the collection method should use
-        # CanCan's accessible_by method to restrict the actual records returned
-
-        instance_variable_set("@#{controller_name}", @collection)
-      end
-    end
-
-    def load_resource_instance
-      if new_actions.include?(action)
-        build_resource
-      elsif params[:id]
-        find_resource
-      end
-    end
-
-    def parent_data
-      self.class.parent_data
-    end
-
-    def parent
-      if parent_data.present?
-        @parent ||= parent_data[:model_class].send("find_by_#{parent_data[:find_by]}", params["#{model_name}_id"])
-        instance_variable_set("@#{model_name}", @parent)
-      else
-        nil
-      end
-    end
-
-    def find_resource
-      if parent_data.present?
-        parent.send(controller_name).find(params[:id])
-      else
-        model_class.find(params[:id])
-      end
-    end
-
-    def build_resource
-      if parent_data.present?
-        parent.send(controller_name).build
-      else
-        model_class.new
-      end
-    end
-
-    def collection
-      return parent.send(controller_name) if parent_data.present?
-      if model_class.respond_to?(:accessible_by) && !current_ability.has_block?(params[:action], model_class)
-        model_class.accessible_by(current_ability, action)
-      else
-        model_class.scoped
-      end
-    end
-
-    def location_after_destroy
-      collection_url
-    end
-
-    def location_after_save
-      collection_url
-    end
-
-    def invoke_callbacks(action, callback_type)
-      callbacks = self.class.callbacks || {}
-      return if callbacks[action].nil?
-      case callback_type.to_sym
-        when :before then callbacks[action].before_methods.each {|method| send method }
-        when :after  then callbacks[action].after_methods.each  {|method| send method }
-        when :fails  then callbacks[action].fails_methods.each  {|method| send method }
-      end
-    end
-
-    # URL helpers
-
-    def new_object_url(options = {})
-      if parent_data.present?
-        spree.new_polymorphic_url([:admin, parent, model_class], options)
-      else
-        spree.new_polymorphic_url([:admin, model_class], options)
-      end
-    end
-
-    def edit_object_url(object, options = {})
-      if parent_data.present?
-        spree.send "edit_admin_#{model_name}_#{object_name}_url", parent, object, options
-      else
-        spree.send "edit_admin_#{object_name}_url", object, options
-      end
-    end
-
-    def object_url(object = nil, options = {})
-      target = object ? object : @object
-      if parent_data.present?
-        spree.send "admin_#{model_name}_#{object_name}_url", parent, target, options
-      else
-        spree.send "admin_#{object_name}_url", target, options
-      end
-    end
-
-    def collection_url(options = {})
-      if parent_data.present?
-        spree.polymorphic_url([:admin, parent, model_class], options)
-      else
-        spree.polymorphic_url([:admin, model_class], options)
-      end
-    end
-
-    def collection_actions
-      [:index]
-    end
-
-    def member_action?
-      !collection_actions.include? action
-    end
-
-    def new_actions
-      [:new, :create]
-    end
-end

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

@@ -1,21 +0,0 @@
-module Spree
-  module Admin
-    class ReturnAuthorizationsController < ResourceController
-      belongs_to 'spree/order', :find_by => :number
-
-      update.after :associate_inventory_units
-      create.after :associate_inventory_units
-
-      def fire
-        @return_authorization.send("#{params[:e]}!")
-        flash[:success] = t(:return_authorization_updated)
-        respond_with(@return_authorization) { |format| format.html { redirect_to :back } }
-      end
-
-      protected
-        def associate_inventory_units
-          (params[:return_quantity] || []).each { |variant_id, qty| @return_authorization.add_variant(variant_id.to_i, qty.to_i) }
-        end
-    end
-  end
-end