active_scaffold_config_list 3.6.3 → 4.1.0

data/config/locales/es.yml

@@ -5,4 +5,8 @@ es:
     config_list_model: "Configurar columnas de %{model}"
     columns: Columnas
     default_sorting: Orden por defecto
+    default_view: Por defecto
     desc: desc
+    global_view: Vista global
+    rename_view: 'Renombrar la vista "%{view_name}"'
+    view_name: Nombre de vista

data/config/locales/fr.yml

@@ -5,4 +5,8 @@ fr:
     config_list_model: "Configurer les colonnes pour %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/hu.yml

@@ -5,4 +5,8 @@ hu:
     config_list_model: "Configure Columns for %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/ja.yml

@@ -5,4 +5,8 @@ ja:
     config_list_model: "Configure Columns for %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/ru.yml

@@ -5,4 +5,8 @@ ru:
     config_list_model: "%{model}: настройки списка"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/lib/active_scaffold/actions/config_list.rb

@@ -2,22 +2,65 @@ module ActiveScaffold::Actions
   module ConfigList
     
     def self.included(base)
-      base.before_action :store_config_list_params, :set_default_sorting, only: [:index]
-      base.helper_method :config_list_params, :config_list_sorting
+      base.before_action :set_default_view, :set_default_sorting, :change_view, only: [:index]
+      base.before_action :config_list_authorized_filter, only: [:show_config_list, :config_list]
+      base.helper_method :config_list_params, :config_list_sorting, :config_list_named_views
     end
 
     def show_config_list
-      respond_to do |type|
-        type.html do
-          render(action: 'show_config_list_form', layout: true)
-        end
-        type.js do
-          render(partial: 'show_config_list_form', layout: false)
-        end
+      config_list_record
+      @config_list_view_name = find_view_name(params[:config_list_view])
+      if @config_list_view_name.present?
+        @global_view = config_list_slug(@config_list_view_name, true) == params[:config_list_view]
       end
+      respond_to_action(:show_config_list, config_list_formats)
+    end
+
+    def config_list
+      do_config_list
+      respond_to_action(:config_list, config_list_formats)
     end
     
     protected
+
+    def set_default_view
+      return unless params[:config_list_view].nil?
+
+      default_view = active_scaffold_config.config_list.default_view
+      params[:config_list_view] = default_view.to_s if default_view.present?
+    end
+
+    def change_view
+      active_scaffold_config.list.refresh_with_header = true if params[:config_list_view]
+    end
+
+    def config_list_formats
+      [:html, :js]
+    end
+
+    def show_config_list_respond_to_html
+      render(action: 'show_config_list_form', layout: true)
+    end
+
+    def show_config_list_respond_to_js
+      render(partial: 'show_config_list_form', layout: false)
+    end
+
+    def config_list_respond_to_html
+      redirect_to action: :index, config_list_view: params[:config_list_view_name]
+    end
+
+    def do_refresh_list
+      set_default_sorting
+      super
+    end
+
+    def config_list_respond_to_js
+      do_refresh_list
+      active_scaffold_config.list.refresh_with_header = true
+      list_url = params_for(action: :index, config_list_view: params[:config_list_view].presence)
+      render partial: 'refresh_list', locals: {history_url: url_for(list_url)}, formats: [:js]
+    end
     
     def set_default_sorting
       if (params['sort_direction'] && params['sort_direction'] == 'reset') || (active_scaffold_config.list.user['sort'].blank? && params['sort'].blank?)
@@ -25,15 +68,13 @@ module ActiveScaffold::Actions
       end
     end
 
-    def store_config_list_params
-      if params[:config_list]
-        config_list = params.delete :config_list
-        case config_list
-        when String
-          delete_config_list_params
-        when Array
-          save_config_list_params(config_list, config_list_sorting_params)
-        end
+    def do_config_list
+      config_list = params.delete :config_list
+      case config_list
+      when String
+        delete_config_list_params(params.delete(:config_list_view).presence)
+      when Array
+        save_config_list_params(config_list, config_list_sorting_params, params.delete(:config_list_view_name).presence, params.delete(:config_list_old_view_name))
       end
     end
     
@@ -70,9 +111,13 @@ module ActiveScaffold::Actions
       @active_scaffold_current_user ||= send(self.class.active_scaffold_config.class.security.current_user_method)
     end
 
-    def delete_config_list_params
-      if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-        active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name).destroy
+    def delete_config_list_params(view_name)
+      record = config_list_record(view_name)
+      if record
+        if record.destroy && view_name.present?
+          config_list_record(reload: true)
+          return
+        end
       else
         config_list_session_storage['config_list'] = nil
         config_list_session_storage['config_list_sorting'] = nil
@@ -82,12 +127,17 @@ module ActiveScaffold::Actions
       @config_list_sorting = nil
     end
 
-    def save_config_list_params(config_list, config_list_sorting)
-      if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-        record = active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name)
-        record.config_list = config_list.join(',')
+    def save_config_list_params(config_list, config_list_sorting, view_name, old_view_name)
+      if view_name.present?
+        assign = {view_name: view_name}
+        assign[:slug] = config_list_slug(view_name, params.delete(:global_view).present?) if active_scaffold_config.config_list.global_views
+      end
+      record = config_list_record(old_view_name || assign&.dig(:slug) || view_name, assign: assign)
+
+      if record
+        record.config_list = config_list.select(&:present?).join(',')
         record.config_list_sorting = config_list_sorting if record.respond_to? :config_list_sorting
-        record.save
+        params[:config_list_view] = assign&.dig(:slug) || view_name if record.save
       else
         config_list_session_storage['config_list'] = config_list.map(&:to_sym)
         config_list_session_storage['config_list_sorting'] = config_list_sorting
@@ -111,14 +161,52 @@ module ActiveScaffold::Actions
       end
     end
 
-    def config_list_record
-      return @config_list_record if defined? @config_list_record
+    def config_list_record(view_name = params[:config_list_view], reload: false, assign: nil)
+      return @config_list_record if !reload && defined?(@config_list_record)
       @config_list_record =
         if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-          active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name)
+          if view_name.present?
+            options = {attributes: assign}
+            options[active_scaffold_config.config_list.global_views ? :slug : :view_name] = view_name
+          end
+          active_scaffold_current_user.send(
+            active_scaffold_config.config_list.save_to_user,
+            config_list_session_storage_key,
+            config_list_controller_name,
+            **options
+          )
         end
     end
 
+    def find_view_name(slug)
+      return unless slug.present?
+
+      config_list_named_views.find do |view_name, view_slug|
+        break view_name if slug == (view_slug || view_name)
+      end
+    end
+
+    def config_list_slug(view_name, global_view)
+      return view_name unless active_scaffold_config.config_list.global_views
+
+      if ActiveScaffold::Config::ConfigList.slug_builder
+        send(ActiveScaffold::Config::ConfigList.slug_builder, view_name, global_view)
+      elsif global_view
+        "global-#{view_name}"
+      else
+        "user-#{view_name}"
+      end
+    end
+
+    def config_list_named_views
+      @config_list_named_views ||=
+        active_scaffold_current_user.send(
+          active_scaffold_config.config_list.named_views_method,
+          config_list_session_storage_key,
+          config_list_controller_name
+        ).compact
+    end
+
     def config_list_params
       unless defined? @config_list_params
         @config_list_params =
@@ -139,7 +227,9 @@ module ActiveScaffold::Actions
     def config_list_sorting
       unless defined? @config_list_sorting
         @config_list_sorting =
-          if config_list_record
+          if named_view
+            named_view.sorting
+          elsif config_list_record
             config_list_record.config_list_sorting if config_list_record.respond_to? :config_list_sorting
           else
             config_list_session_storage['config_list_sorting']
@@ -149,7 +239,7 @@ module ActiveScaffold::Actions
     end
 
     def list_columns
-      @list_columns ||= begin
+      @list_columns ||= named_view_columns || begin
         columns = super
         if config_list_params.present?
           config_list = config_list_params.each.with_index.to_h
@@ -164,7 +254,24 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def config_list_authorized?
-      authorized_for?(action: :read)
+      named_view.nil? && authorized_for?(action: :read)
+    end
+
+    def named_view
+      return @named_view unless params[:config_list_view].present?
+
+      @named_view ||= active_scaffold_config.config_list.named_views.find { |v| v.name == params[:config_list_view] }
+    end
+
+    def named_view_columns
+      return unless named_view
+
+      raise ActiveScaffold::ActionNotAllowed if named_view.security_method && !send(named_view.security_method)
+      named_view.columns.visible_columns(flatten: true)
+    end
+
+    def config_list_authorized_filter
+      raise ActiveScaffold::ActionNotAllowed unless config_list_authorized?
     end
   end
 end

data/lib/active_scaffold/config/config_list.rb

@@ -5,7 +5,14 @@ module ActiveScaffold::Config
       super
       @link = self.class.link.clone unless self.class.link.nil?
       @save_to_user = self.class.save_to_user
+      @named_views_method = self.class.named_views_method
       @draggable = self.class.draggable
+      @named_views_position = self.class.named_views_position
+      @named_views_selector = self.class.named_views_selector
+      @default_view = self.class.default_view
+      @unnamed_view_security_method = self.class.unnamed_view_security_method
+      @global_views = self.class.global_views
+      @named_views = []
     end
 
     # global level configuration
@@ -26,6 +33,35 @@ module ActiveScaffold::Config
     # configures the method in user model to save list configuration for every controller
     cattr_accessor :save_to_user
 
+    # configures the method in user model to return the named views saved for the user,
+    # setting it enables saving the views, but requires to set a method in save_to_user
+    cattr_accessor :named_views_method
+
+    # the position to place the named views selector, :left (next to the title),
+    # :right or :center (default, before the actions and filters)
+    cattr_accessor :named_views_position
+    @@named_views_position = :center
+
+    # the type of selector for named views, :links, :select or :radio
+    cattr_accessor :named_views_selector
+    @@named_views_selector = :links
+
+    # named view selected when config_list_view is not present in the request
+    cattr_accessor :default_view
+
+    # method used to check whether the unnamed, configurable list view is available
+    cattr_accessor :unnamed_view_security_method
+
+    # if saving global views is allowed, or named views are always saved for the current user only
+    cattr_accessor :global_views
+
+    # Configures the method to convert a view name to slug, used only when global views are enabled
+    # Slugs are needed when global views are enabled, to ensure the name in the params is unique
+    # although a user view has the same name as a global view
+    # By default is generated with the prefixes global- and user-, but a different method can be setup here
+    # so it can be defined in ApplicationController
+    cattr_accessor :slug_builder
+
     # enable draggable lists to select displayed columns (enabled by default)
     cattr_accessor :draggable
     self.draggable = true
@@ -44,6 +80,29 @@ module ActiveScaffold::Config
     # configures the method in user model to save list configuration for every controller
     attr_accessor :save_to_user
 
+    # configures the method in user model to return the named views saved for the user,
+    # setting it enables saving the views, but requires to set a method in save_to_user
+    attr_accessor :named_views_method
+
+    # the position to place the named views selector, :left (next to the title),
+    # :right or :center (default, before the actions and filters)
+    attr_accessor :named_views_position
+
+    # the type of selector for named views, :links, :select or :radio
+    attr_accessor :named_views_selector
+
+    # named view selected when config_list_view is not present in the request
+    attr_accessor :default_view
+
+    # method used to check whether the unnamed, configurable list view is available
+    attr_accessor :unnamed_view_security_method
+
+    # if saving global views is allowed, or named views are always saved for the current user only
+    attr_accessor :global_views
+
+    # generic named views
+    attr_reader :named_views
+
     # enable draggable lists to select displayed columns
     attr_accessor :draggable
 
@@ -52,12 +111,25 @@ module ActiveScaffold::Config
       columns.exclude :created_on, :created_at, :updated_on, :updated_at, :as_marked
       columns.exclude *@core.columns.select{|c| c.association.try(:polymorphic?)}.map(&:name)
     end
-    
+
     # the ActionLink for this action
     attr_accessor :link
 
+    def add_view(name, columns = nil, &)
+      raise ArgumentError, "view '#{name}' already exists" if @named_views.find { |v| v.name == name }
+      view = ::ActiveScaffold::DataStructures::NamedView.new(name, self)
+      view.columns = columns if columns
+      yield view if block_given?
+      view.columns ||= [] if view.view
+      raise ArgumentError, "no columns defined for view '#{name}'" if view.view.blank? && view.columns.empty?
+
+      @named_views << view
+      view
+    end
+
     UserSettings.class_eval do
-      user_attr :default_columns, :save_to_user, :draggable
+      user_attr :default_columns, :save_to_user, :named_views_method, :draggable,
+                :named_views_position, :named_views_selector, :default_view, :unnamed_view_security_method, :global_views
 
       def label
         @conf.label(core: core)

data/lib/active_scaffold/data_structures/named_view.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveScaffold::DataStructures
+  class NamedView
+    # the internal name of the view
+    attr_reader :name
+
+    # the label displayed to the user, if it's a symbol will be translated with as_
+    attr_writer :label
+
+    # the method used to check permissions, if returns true, the list view is allowed
+    attr_accessor :security_method
+
+    # the columns in the named view
+    attr_reader :columns
+
+    # default sorting used with this view instead of default
+    attr_accessor :sorting
+
+    # custom partial used to render the list for this view
+    attr_accessor :view
+
+    # additional information displayed as a title in the view selector
+    attr_accessor :tooltip
+
+    def initialize(name, action)
+      @name = name.to_s
+      @action = action
+      @label = name
+    end
+
+    # the label displayed to the user
+    def label
+      case @label
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) }
+      else
+        @label
+      end
+    end
+
+    def columns=(columns)
+      @columns = ActionColumns.new(columns).tap { |cols| cols.action = @action }
+    end
+  end
+end

data/lib/active_scaffold/helpers/config_list_helpers.rb

@@ -9,6 +9,30 @@ module ActiveScaffold
         true
       end
 
+      def ignore_param_for_nested?(key)
+        super || key == :config_list_view
+      end
+
+      def named_view
+        controller.send(:named_view) if active_scaffold_config.actions.include?(:config_list)
+      end
+
+      def config_list_save_named_views?
+        active_scaffold_config.config_list.named_views_method.present?
+      end
+
+      def config_list_named_views?
+        return unless active_scaffold_config.actions.include? :config_list
+
+        config_list_save_named_views? || active_scaffold_config.config_list.named_views.present?
+      end
+
+      def config_list_global_views?
+        return unless active_scaffold_config.actions.include? :config_list
+
+        config_list_save_named_views? && active_scaffold_config.config_list.global_views
+      end
+
       def config_list_columns
         columns =
           if config_list_params.is_a?(Array)
@@ -19,6 +43,70 @@ module ActiveScaffold
           end
         columns.map { |c| [column_heading_label(c), c.name] }
       end
+
+      def user_named_views
+        return [] unless config_list_save_named_views?
+        config_list_named_views
+      end
+
+      def named_views_from_config
+        active_scaffold_config.config_list.named_views.filter_map do |view|
+          next if view.security_method && !controller.send(view.security_method)
+          [view.label, view.name, view.tooltip]
+        end
+      end
+
+      def config_list_unnamed_view?
+        security_method = active_scaffold_config.config_list.unnamed_view_security_method
+        security_method.nil? || controller.send(security_method)
+      end
+
+      def active_scaffold_named_view_selector
+        named_views = user_named_views + named_views_from_config
+        return unless named_views.any?
+
+        named_views.unshift [as_(:default_view), ''] if config_list_unnamed_view?
+        html = config_list_view_options(named_views, params[:config_list_view].to_s)
+        if active_scaffold_config.config_list.named_views_selector == :select
+          select_options = as_element_attributes(:config_list_view_select, id: nil)
+          html = select_tag('config_list_view', html, select_options)
+        end
+        html
+      end
+
+      def config_list_view_options(named_views, selected)
+        case active_scaffold_config.config_list.named_views_selector
+        when :links
+          url = url_for(params_for(action: :index, config_list_view: '--VIEW--'))
+          view = nil
+          links = named_views.map do |label, name, tooltip|
+            name ||= label
+            link_options = as_element_attributes(:config_list_view_link, remote: true, title: tooltip)
+            link = link_to(label, url.sub('--VIEW--', ERB::Util.unwrapped_html_escape(name)), link_options)
+            view = label if name == selected
+            as_element :config_list_view_item, link, class: ('selected' if name == selected)
+          end
+          as_element(:config_list_view_selected, view || as_(:default_view), class: 'selected-view') +
+            as_element(:config_list_views_list, safe_join(links), class: 'views')
+
+        when :select
+          options = named_views.map do |label, name, tooltip|
+            option_attributes = as_element_attributes(:config_list_view_option, title: tooltip).to_h.compact
+            [label, name || label, option_attributes]
+          end
+          options_for_select(options, selected)
+
+        when :radio
+          buttons = named_views.map do |label, name, tooltip|
+            name ||= label
+            radio_options = as_element_attributes(:config_list_view_radio, id: nil)
+            as_element(:config_list_view_label, title: tooltip) do
+              radio_button_tag('config_list_view', name, name == selected, **radio_options.to_h) + label
+            end
+          end
+          safe_join(buttons)
+        end
+      end
     end
   end
-end
+end

data/lib/active_scaffold_config_list/config_listable.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveScaffoldConfigList
+  # app/models/concerns/config_listable.rb
+  module ConfigListable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_config_lists(model_name,
+                           association_name: :list_configurations,
+                           association_options: {},
+                           view_name_column: :view_name,
+                           slug_column: :slug,
+                           controller_column: :controller_id,
+                           controller_matcher: :controller_name)
+        # Define the association
+        class_eval do
+          has_many association_name, class_name: model_name, **association_options
+        end
+
+        model_class = model_name.to_s.classify.constantize
+        view_name_column = nil unless model_class.column_names.include?(view_name_column.to_s)
+        slug_column = nil unless model_class.column_names.include?(slug_column.to_s)
+
+        self.config_list_settings = {
+          association_name: association_name,
+          model_name: model_name,
+          view_name_column: view_name_column,
+          slug_column: slug_column,
+          controller_column: controller_column,
+          model_class: model_class,
+          foreign_key: reflect_on_association(association_name).foreign_key,
+          controller_matcher: controller_matcher
+        }.freeze
+
+        # Include instance methods
+        include ConfigListable::InstanceMethods unless included_modules.include?(ConfigListable::InstanceMethods)
+      end
+    end
+
+    included do
+      class_attribute :config_list_settings, instance_writer: false, default: nil
+    end
+
+    module InstanceMethods
+      def config_list_for(controller_id, controller_name, view_name: nil, slug: nil, attributes: nil)
+        settings = self.class.config_list_settings
+        query = list_configurations_query(controller_id, controller_name, user_views: slug.nil? || slug.to_s.start_with?('user-'))
+
+        if slug
+          query = query.where(settings[:slug_column] => slug)
+        elsif view_name
+          query = query.where(settings[:view_name_column] => view_name)
+        else
+          column = settings[:slug_column] || settings[:view_name_column]
+          query = query.where(column => nil) if column
+        end
+
+        query.first_or_initialize.tap do |record|
+          record.attributes = map_attribute_names(attributes, settings) if attributes
+        end
+      end
+
+      def config_list_views(controller_id, controller_name)
+        settings = self.class.config_list_settings
+        list_configurations_query(controller_id, controller_name)
+          .where.not(settings[:view_name_column] => nil)
+          .pluck([settings[:view_name_column], settings[:slug_column]].compact)
+      end
+
+      private
+
+      def determine_controller_value(controller_id, controller_name, settings)
+        matcher = settings[:controller_matcher]
+
+        case matcher
+        when :controller_id
+          {settings[:controller_column] => controller_id}
+        else
+          # Default to controller_id if matcher is a callable
+          if matcher.respond_to?(:call)
+            matcher.call(controller_id, controller_name)
+          else
+            # Fallback to controller_name
+            {settings[:controller_column] => controller_name}
+          end
+        end
+      end
+
+      def list_configurations_query(controller_id, controller_name, user_views: false)
+        settings = self.class.config_list_settings
+        query = send(settings[:association_name])
+        # Add the OR condition if user_views is false
+        query = settings[:model_class].where(settings[:foreign_key] => nil).or(query) unless user_views
+        query.where(determine_controller_value(controller_id, controller_name, settings))
+      end
+
+      def map_attribute_names(attributes, settings)
+        return attributes unless attributes.is_a?(Hash)
+
+        attributes.symbolize_keys.transform_keys do |key|
+          case key
+          when :view_name then settings[:view_name_column]
+          when :slug then settings[:slug_column]
+          else
+            key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold_config_list/engine.rb

@@ -1,8 +1,10 @@
+require 'active_scaffold_config_list/config_listable'
 module ActiveScaffoldConfigList
   class Engine < ::Rails::Engine
     initializer 'active_scaffold_config_list.routes' do
       ActiveSupport.on_load :active_scaffold_routing do
         self::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:show_config_list] = :get
+        self::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:config_list] = :post
       end
     end
 
@@ -11,5 +13,11 @@ module ActiveScaffoldConfigList
         ActionView::Base.send :include, ActiveScaffold::Helpers::ConfigListHelpers
       end
     end
+
+    initializer 'active_scaffold_config_list.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        include ActiveScaffoldConfigList::ConfigListable
+      end
+    end
   end
 end