activeadmin-rails 1.7.0

data/lib/active_admin/base_controller/authorization.rb

@@ -0,0 +1,126 @@
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Authorization
+      extend ActiveSupport::Concern
+
+      ACTIONS_DICTIONARY = {
+        index:   ActiveAdmin::Authorization::READ,
+        show:    ActiveAdmin::Authorization::READ,
+        new:     ActiveAdmin::Authorization::CREATE,
+        create:  ActiveAdmin::Authorization::CREATE,
+        edit:    ActiveAdmin::Authorization::UPDATE,
+        update:  ActiveAdmin::Authorization::UPDATE,
+        destroy: ActiveAdmin::Authorization::DESTROY
+      }
+
+      included do
+        rescue_from ActiveAdmin::AccessDenied, with: :dispatch_active_admin_access_denied
+
+        helper_method :authorized?
+        helper_method :authorize!
+      end
+
+      protected
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean]
+      #
+      def authorized?(action, subject = nil)
+        active_admin_authorization.authorized?(action, subject)
+      end
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views. If the action is not allowd, it raises
+      # an ActiveAdmin::AccessDenied exception.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean] True if authorized, otherwise raises
+      #                 an ActiveAdmin::AccessDenied.
+      def authorize!(action, subject = nil)
+        unless authorized? action, subject
+          raise ActiveAdmin::AccessDenied.new(current_active_admin_user,
+                                              action,
+                                              subject)
+        end
+      end
+
+      # Performs authorization on the resource using the current controller
+      # action as the permission action.
+      #
+      def authorize_resource!(resource)
+        permission = action_to_permission(params[:action])
+        authorize! permission, resource
+      end
+
+      # Retrieve or instantiate the authorization instance for this resource
+      #
+      # @return [ActiveAdmin::AuthorizationAdapter]
+      def active_admin_authorization
+        @active_admin_authorization ||=
+         active_admin_authorization_adapter.new active_admin_config, current_active_admin_user
+      end
+
+      # Returns the class to be used as the authorization adapter
+      #
+      # @return [Class]
+      def active_admin_authorization_adapter
+        adapter = active_admin_namespace.authorization_adapter
+        if adapter.is_a? String
+          adapter.constantize
+        else
+          adapter
+        end
+      end
+
+      # Converts a controller action into one of the correct Active Admin
+      # authorization names. Uses the ACTIONS_DICTIONARY to convert the
+      # action name to permission.
+      #
+      # @param [String, Symbol] action The controller action name.
+      #
+      # @return [Symbol] The permission name to use.
+      def action_to_permission(action)
+        if action && action = action.to_sym
+          Authorization::ACTIONS_DICTIONARY[action] || action
+        end
+      end
+
+      def dispatch_active_admin_access_denied(exception)
+        instance_exec(self, exception, &active_admin_namespace.on_unauthorized_access.to_proc)
+      end
+
+      def rescue_active_admin_access_denied(exception)
+        error = exception.message
+
+        respond_to do |format|
+          format.html do
+            flash[:error] = error
+            redirect_backwards_or_to_root
+          end
+
+          format.csv  { render body:          error,           status: :unauthorized }
+          format.json { render json: { error: error },         status: :unauthorized }
+          format.xml  { render xml: "<error>#{error}</error>", status: :unauthorized }
+        end
+      end
+
+      def redirect_backwards_or_to_root
+        redirect_back fallback_location: active_admin_root
+      end
+
+    end
+  end
+end

data/lib/active_admin/base_controller/menu.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Menu
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_current_tab
+        helper_method :current_menu
+      end
+
+      protected
+
+      def current_menu
+        active_admin_config.navigation_menu
+      end
+
+      # Set's @current_tab to be name of the tab to mark as current
+      # Get's called through a before filter
+      def set_current_tab
+        @current_tab = active_admin_config.menu_item
+
+        if current_menu && active_admin_config.belongs_to? && parent?
+          parent_item = active_admin_config.belongs_to_config.target.menu_item
+          if current_menu.include? parent_item
+            @current_tab = parent_item
+          end
+        else
+          @current_tab = active_admin_config.menu_item
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/base_controller.rb

@@ -0,0 +1,91 @@
+require 'active_admin/base_controller/authorization'
+require 'active_admin/base_controller/menu'
+
+module ActiveAdmin
+  # BaseController for ActiveAdmin.
+  # It implements ActiveAdmin controllers core features.
+  class BaseController < ::InheritedResources::Base
+    helper ::ActiveAdmin::ViewHelpers
+    helper_method :env
+
+    layout 'active_admin'
+
+    before_action :only_render_implemented_actions
+    before_action :authenticate_active_admin_user
+
+    class << self
+      # Ensure that this method is available for the DSL
+      public :actions
+
+      # Reference to the Resource object which initialized
+      # this controller
+      attr_accessor :active_admin_config
+    end
+
+    # By default Rails will render un-implemented actions when the view exists. Because Active
+    # Admin allows you to not render any of the actions by using the #actions method, we need
+    # to check if they are implemented.
+    def only_render_implemented_actions
+      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
+    end
+
+    include Authorization
+    include Menu
+
+    private
+
+    # Calls the authentication method as defined in ActiveAdmin.authentication_method
+    def authenticate_active_admin_user
+      send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
+    end
+
+    def current_active_admin_user
+      send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
+    end
+    helper_method :current_active_admin_user
+
+    def current_active_admin_user?
+      !!current_active_admin_user
+    end
+    helper_method :current_active_admin_user?
+
+    def active_admin_config
+      self.class.active_admin_config
+    end
+    helper_method :active_admin_config
+
+    def active_admin_namespace
+      active_admin_config.namespace
+    end
+    helper_method :active_admin_namespace
+
+    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+
+    def active_admin_root
+      controller, action = active_admin_namespace.root_to.split '#'
+      {controller: controller, action: action}
+    end
+
+    def page_presenter
+      active_admin_config.get_page_presenter(params[:action].to_sym) || default_page_presenter
+    end
+    helper_method :page_presenter
+
+    def default_page_presenter
+      PagePresenter.new
+    end
+
+    def page_title
+      if page_presenter[:title]
+        helpers.render_or_call_method_or_proc_on(self, page_presenter[:title])
+      else
+        default_page_title
+      end
+    end
+    helper_method :page_title
+
+    def default_page_title
+      active_admin_config.name
+    end
+  end
+end

data/lib/active_admin/batch_actions/controller.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module BatchActions
+    module Controller
+
+      # Controller action that is called when submitting the batch action form
+      def batch_action
+        if action_present?
+          selection  =            params[:collection_selection] || []
+          inputs     = JSON.parse params[:batch_action_inputs]  || '{}'
+          valid_keys = StringSymbolOrProcSetting.new(current_batch_action.inputs).value(self).try(:keys)
+          inputs     = inputs.with_indifferent_access.slice *valid_keys
+          method_name = "batch_action_#{params[:batch_action]}"
+          if respond_to?(method_name, true)
+            send method_name, selection, inputs
+          else
+            instance_exec selection, inputs, &current_batch_action.block
+          end
+        else
+          raise "Couldn't find batch action \"#{params[:batch_action]}\""
+        end
+      end
+
+      protected
+
+      def action_present?
+        params[:batch_action].present? && current_batch_action
+      end
+
+      def current_batch_action
+        active_admin_config.batch_actions.detect{ |action| action.sym.to_s == params[:batch_action] }
+      end
+
+      COLLECTION_APPLIES = [
+        :authorization_scope,
+        :filtering,
+        :scoping,
+        :includes,
+      ].freeze
+
+      def batch_action_collection(only = COLLECTION_APPLIES)
+        find_collection(only: only)
+      end
+    end
+  end
+end

data/lib/active_admin/batch_actions/resource_extension.rb

@@ -0,0 +1,151 @@
+module ActiveAdmin
+
+  module BatchActions
+    module ResourceExtension
+      def initialize(*)
+        super
+        @batch_actions = {}
+        add_default_batch_action
+      end
+
+      # @return [Array] The set of batch actions for this resource
+      def batch_actions
+        batch_actions_enabled? ? @batch_actions.values.sort : []
+      end
+
+      # @return [Boolean] If batch actions are enabled for this resource
+      def batch_actions_enabled?
+        # If the resource config has been set, use it. Otherwise
+        # return the namespace setting
+        @batch_actions_enabled.nil? ? namespace.batch_actions : @batch_actions_enabled
+      end
+
+      # Disable or Enable batch actions for this resource
+      # Set to `nil` to inherit the setting from the namespace
+      def batch_actions=(bool)
+        @batch_actions_enabled = bool
+      end
+
+      # Add a new batch item to a resource
+      # @param [String] title
+      # @param [Hash] options
+      # => :if is a proc that will be called to determine if the BatchAction should be displayed
+      # => :sort_order is used to sort the batch actions ascending
+      # => :confirm is a string to prompt the user with (or a boolean to use the default message)
+      # => :form is a Hash of form fields you want the user to fill out
+      #
+      def add_batch_action(sym, title, options = {}, &block)
+        @batch_actions[sym] = ActiveAdmin::BatchAction.new(sym, title, options, &block)
+      end
+
+      # Remove a batch action
+      # @param [Symbol] sym
+      # @return [ActiveAdmin::BatchAction] the batch action, if it was present
+      #
+      def remove_batch_action(sym)
+        @batch_actions.delete(sym.to_sym)
+      end
+
+      # Clears all the existing batch actions for this resource
+      def clear_batch_actions!
+        @batch_actions = {}
+      end
+
+      private
+
+      # @return [ActiveAdmin::BatchAction] The default "delete" action
+      def add_default_batch_action
+        destroy_options = {
+          priority: 100,
+          confirm: proc{ I18n.t('active_admin.batch_actions.delete_confirmation', plural_model: active_admin_config.plural_resource_label.downcase) },
+          if: proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
+        }
+
+        add_batch_action :destroy, proc { I18n.t('active_admin.delete') }, destroy_options do |selected_ids|
+          batch_action_collection.find(selected_ids).each do |record|
+            authorize! ActiveAdmin::Auth::DESTROY, record
+            destroy_resource(record)
+          end
+
+          redirect_to active_admin_config.route_collection_path(params),
+                      notice: I18n.t("active_admin.batch_actions.succesfully_destroyed",
+                                        count: selected_ids.count,
+                                        model: active_admin_config.resource_label.downcase,
+                                        plural_model: active_admin_config.plural_resource_label(count: selected_ids.count).downcase)
+        end
+      end
+
+    end
+  end
+
+  class BatchAction
+
+    include Comparable
+
+    attr_reader :block, :title, :sym
+
+    DEFAULT_CONFIRM_MESSAGE = proc{ I18n.t 'active_admin.batch_actions.default_confirmation' }
+
+    # Create a Batch Action
+    #
+    # Examples:
+    #
+    #   BatchAction.new :flag
+    # => Will create an action that appears in the action list popover
+    #
+    #   BatchAction.new(:flag) { |selection| redirect_to collection_path, notice: "#{selection.length} users flagged" }
+    # => Will create an action that uses a block to process the request (which receives one paramater of the selected objects)
+    #
+    #   BatchAction.new("Perform Long Operation on") { |selection| }
+    # => You can create batch actions with a title instead of a Symbol
+    #
+    #   BatchAction.new(:flag, if: proc{ can? :flag, AdminUser }) { |selection| }
+    # => You can provide an `:if` proc to choose when the batch action should be displayed
+    #
+    #   BatchAction.new :flag, confirm: true
+    # => You can pass `true` to `:confirm` to use the default confirm message.
+    #
+    #   BatchAction.new(:flag, confirm: "Are you sure?") { |selection| }
+    # => You can pass a custom confirmation message through `:confirm`
+    #
+    #   BatchAction.new(:flag, form: {foo: :text, bar: :checkbox}) { |selection, inputs| }
+    # => You can pass a hash of options to `:form` that will be rendered as form input fields for the user to fill out.
+    #
+    def initialize(sym, title, options = {}, &block)
+      @sym, @title, @options, @block, @confirm = sym, title, options, block, options[:confirm]
+      @block ||= proc {}
+    end
+
+    def confirm
+      if @confirm == true
+        DEFAULT_CONFIRM_MESSAGE
+      elsif !@confirm && @options[:form]
+        DEFAULT_CONFIRM_MESSAGE
+      else
+        @confirm
+      end
+    end
+
+    def inputs
+      @options[:form]
+    end
+
+    # Returns the display if block. If the block was not explicitly defined
+    # a default block always returning true will be returned.
+    def display_if_block
+      @options[:if] || proc{ true }
+    end
+
+    # Used for sorting
+    def priority
+      @options[:priority] || 10
+    end
+
+    # sort operator
+    def <=>(other)
+      self.priority <=> other.priority
+    end
+
+  end
+
+end

data/lib/active_admin/batch_actions/views/batch_action_form.rb

@@ -0,0 +1,45 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Build a BatchActionForm
+    class BatchActionForm < ActiveAdmin::Component
+      builder_method :batch_action_form
+
+      attr_reader :prefix_html
+
+      def build(options = {}, &block)
+        options[:id] ||= "collection_selection"
+
+        # Open a form with two hidden input fields:
+        # batch_action        => name of the specific action called
+        # batch_action_inputs => a JSON string of any requested confirmation values
+        text_node form_tag active_admin_config.route_batch_action_path(params, url_options), id: options[:id]
+        input name: :batch_action,        id: :batch_action,        type: :hidden
+        input name: :batch_action_inputs, id: :batch_action_inputs, type: :hidden
+
+        super(options)
+      end
+
+      # Override the default to_s to include a closing form tag
+      def to_s
+        content + closing_form_tag
+      end
+
+      def render_in(context = arbo_context)
+        children.collect do |element|
+          element.render_in_or_to_s(context)
+        end
+        context.output_buffer << closing_form_tag
+      end
+
+      private
+
+      def closing_form_tag
+        '</form>'.html_safe
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/views/batch_action_selector.rb

@@ -0,0 +1,58 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    class BatchActionSelector < ActiveAdmin::Component
+      builder_method :batch_action_selector
+
+      # Build a new batch actions selector
+      #
+      # @param [Array] batch_actions An array of batch actions
+      def build(batch_actions)
+        @batch_actions = Array(batch_actions)
+        @drop_down = build_drop_down
+      end
+
+      # We don't want to wrap the action list (or any other children) in
+      # an unnecessary div, so instead we just return the children
+      def to_s
+        children.to_s
+      end
+
+      private
+
+      def build_drop_down
+        return if batch_actions_to_display.empty?
+        dropdown_menu I18n.t("active_admin.batch_actions.button_label"),
+                      class: "batch_actions_selector dropdown_menu",
+                      button: { class: "disabled" } do
+          batch_actions_to_display.each do |batch_action|
+            confirmation_text = render_or_call_method_or_proc_on(self, batch_action.confirm)
+
+            options = {
+              :class         => "batch_action",
+              "data-action"  => batch_action.sym,
+              "data-confirm" => confirmation_text,
+              "data-inputs"  => render_in_context(self, batch_action.inputs).to_json
+            }
+
+            default_title = render_or_call_method_or_proc_on(self, batch_action.title)
+            title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: default_title)
+            label = I18n.t("active_admin.batch_actions.action_label", title: title)
+
+            item label, "#", **options
+          end
+        end
+      end
+
+      # Return the set of batch actions that should be displayed
+      def batch_actions_to_display
+        @batch_actions.select do |batch_action|
+          call_method_or_proc_on(self, batch_action.display_if_block)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -0,0 +1,38 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Creates the toggle checkbox used to toggle the collection selection on/off
+    class ResourceSelectionToggleCell < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_cell
+
+      def build(label_text = '')
+        label do
+          input type: "checkbox", id: "collection_selection_toggle_all", name: "collection_selection_toggle_all", class: "toggle_all"
+          text_node label_text if label_text.present?
+        end
+      end
+    end
+
+    # Creates the checkbox used to select a resource in the collection selection
+    class ResourceSelectionCell < ActiveAdmin::Component
+      builder_method :resource_selection_cell
+
+      def build(resource)
+        input type: "checkbox", id: "batch_action_item_#{resource.id}", value: resource.id, class: "collection_selection", name: "collection_selection[]"
+      end
+    end
+
+    # Creates a wrapper panel for all index pages, except for the table, as the table has the checkbox in the thead
+    class ResourceSelectionTogglePanel < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_panel
+
+      def build
+        super(id: "collection_selection_toggle_panel")
+        resource_selection_toggle_cell(I18n.t('active_admin.batch_actions.selection_toggle_explanation', default: "(Toggle Selection)"))
+      end
+    end
+
+  end
+end

data/lib/active_admin/batch_actions.rb

@@ -0,0 +1,16 @@
+ActiveAdmin.before_load do |app|
+  require "active_admin/batch_actions/resource_extension"
+  require "active_admin/batch_actions/controller"
+
+  # Add our Extensions
+  ActiveAdmin::Resource.send :include, ActiveAdmin::BatchActions::ResourceExtension
+  ActiveAdmin::ResourceController.send :include, ActiveAdmin::BatchActions::Controller
+
+  # Require all the views
+  require "active_admin/batch_actions/views/batch_action_form"
+  require "active_admin/batch_actions/views/selection_cells"
+  require "active_admin/batch_actions/views/batch_action_selector"
+
+  # Register the views with the view factory
+  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
+end

data/lib/active_admin/callbacks.rb

@@ -0,0 +1,88 @@
+module ActiveAdmin
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    private
+
+    # Simple callback system. Implements before and after callbacks for
+    # use within the controllers.
+    #
+    # We didn't use the ActiveSupport callbacks because they do not support
+    # passing in any arbitrary object into the callback method (which we
+    # need to do)
+
+    def run_callback(method, *args)
+      case method
+      when Symbol
+        send(method, *args)
+      when Proc
+        instance_exec(*args, &method)
+      else
+        raise "Please register with callbacks using a symbol or a block/proc."
+      end
+    end
+
+    module ClassMethods
+
+      private
+
+      # Define a new callback.
+      #
+      # Example:
+      #
+      #   class MyClassWithCallbacks
+      #     include ActiveAdmin::Callbacks
+      #
+      #     define_active_admin_callbacks :save
+      #
+      #     before_save do |arg1, arg2|
+      #       # runs before save
+      #     end
+      #
+      #     after_save :call_after_save
+      #
+      #     def save
+      #       # Will run before, yield, then after
+      #       run_save_callbacks :arg1, :arg2 do
+      #         save!
+      #       end
+      #     end
+      #
+      #     protected
+      #
+      #     def call_after_save(arg1, arg2)
+      #       # runs after save
+      #     end
+      #   end
+      #
+      def define_active_admin_callbacks(*names)
+        names.each do |name|
+          [:before, :after].each do |type|
+            callback_name = "#{type}_#{name}_callbacks"
+            callback_ivar = "@#{callback_name}"
+
+            # def self.before_create_callbacks
+            singleton_class.send :define_method, callback_name do
+              instance_variable_get(callback_ivar) || instance_variable_set(callback_ivar, [])
+            end
+            singleton_class.send :private, callback_name
+
+            # def self.before_create
+            singleton_class.send :define_method, "#{type}_#{name}" do |method = nil, &block|
+              send(callback_name).push method || block
+            end
+          end
+
+          # def run_create_callbacks
+          define_method "run_#{name}_callbacks" do |*args, &block|
+            self.class.send("before_#{name}_callbacks").each{ |cbk| run_callback(cbk, *args) }
+            value = block.try :call
+            self.class.send("after_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
+            return value
+          end
+          send :private, "run_#{name}_callbacks"
+        end
+      end
+    end
+  end
+end