spree_backend 2.0.0.rc1

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

@@ -0,0 +1,45 @@
+class Spree::Admin::PromotionActionsController < Spree::Admin::BaseController
+  before_filter :load_promotion, :only => [:create, :destroy]
+  before_filter :validate_promotion_action_type, :only => :create
+
+  def create
+    @calculators = Spree::Promotion::Actions::CreateAdjustment.calculators
+    @promotion_action = params[:action_type].constantize.new(params[:promotion_action])
+    @promotion_action.promotion = @promotion
+    if @promotion_action.save
+      flash[:success] = Spree.t(:successfully_created, :resource => Spree.t(:promotion_action))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  def destroy
+    @promotion_action = @promotion.promotion_actions.find(params[:id])
+    if @promotion_action.destroy
+      flash[:success] = Spree.t(:successfully_removed, :resource => Spree.t(:promotion_action))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  private
+
+  def load_promotion
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+  end
+
+  def validate_promotion_action_type
+    valid_promotion_action_types = Rails.application.config.spree.promotions.actions.map(&:to_s)
+    if !valid_promotion_action_types.include?(params[:action_type])
+      flash[:error] = Spree.t(:invalid_promotion_action)
+      respond_to do |format|
+        format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+        format.js   { render :layout => false }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+class Spree::Admin::PromotionRulesController < Spree::Admin::BaseController
+  helper 'spree/promotion_rules'
+
+  before_filter :load_promotion, :only => [:create, :destroy]
+  before_filter :validate_promotion_rule_type, :only => :create
+
+  def create
+    # Remove type key from this hash so that we don't attempt
+    # to set it when creating a new record, as this is raises
+    # an error in ActiveRecord 3.2.
+    promotion_rule_type = params[:promotion_rule].delete(:type)
+    @promotion_rule = promotion_rule_type.constantize.new(params[:promotion_rule])
+    @promotion_rule.promotion = @promotion
+    if @promotion_rule.save
+      flash[:success] = Spree.t(:successfully_created, :resource => Spree.t(:promotion_rule))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  def destroy
+    @promotion_rule = @promotion.promotion_rules.find(params[:id])
+    if @promotion_rule.destroy
+      flash[:success] = Spree.t(:successfully_removed, :resource => Spree.t(:promotion_rule))
+    end
+    respond_to do |format|
+      format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+      format.js   { render :layout => false }
+    end
+  end
+
+  private
+
+  def load_promotion
+    @promotion = Spree::Promotion.find(params[:promotion_id])
+  end
+
+  def validate_promotion_rule_type
+    valid_promotion_rule_types = Rails.application.config.spree.promotions.rules.map(&:to_s)
+    if !valid_promotion_rule_types.include?(params[:promotion_rule][:type])
+      flash[:error] = Spree.t(:invalid_promotion_rule)
+      respond_to do |format|
+        format.html { redirect_to spree.edit_admin_promotion_path(@promotion)}
+        format.js   { render :layout => false }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Admin
+    class PromotionsController < ResourceController
+      before_filter :load_data
+      before_filter :load_event_names
+
+      helper 'spree/promotion_rules'
+
+      protected
+        def location_after_save
+          spree.edit_admin_promotion_url(@promotion)
+        end
+
+        def load_data
+          @calculators = Rails.application.config.spree.calculators.promotion_actions_create_adjustments
+        end
+
+        def load_event_names
+          @event_names = Spree::Activator.event_names.map { |name| [Spree.t("events.#{name}"), name] }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+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)
+        render :template => "spree/admin/properties/filtered", :layout => false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Spree
+  module Admin
+    class ReportsController < Spree::Admin::BaseController
+      respond_to :html
+
+      AVAILABLE_REPORTS = {
+        :sales_total => { :name => Spree.t(:sales_total), :description => Spree.t(:sales_total_description) }
+      }
+
+      def index
+        @reports = AVAILABLE_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
+
+      private
+
+      def model_class
+        Spree::Admin::ReportsController
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,261 @@
+require 'spree/backend/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 collection_url }
+        format.js   { render :partial => "spree/admin/shared/destroy" }
+      end
+    else
+      invoke_callbacks(:destroy, :fails)
+      respond_with(@object) do |format|
+        format.html { redirect_to collection_url }
+      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_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