effective_datatables 3.6.3 → 3.7.0

data/app/models/effective/effective_datatable/dsl/bulk_actions.rb

@@ -3,16 +3,16 @@ module Effective
     module Dsl
       module BulkActions
 
-        def bulk_action(*args)
-          datatable._bulk_actions.push(content_tag(:li, link_to_bulk_action(*args)))
+        def bulk_action(title, url, opts = {})
+          datatable._bulk_actions.push(link_to_bulk_action(title, url, opts))
         end
 
-        def bulk_download(*args)
-          datatable._bulk_actions.push(content_tag(:li, link_to_bulk_action(*args), 'data-authenticity-token' => form_authenticity_token))
+        def bulk_download(title, url, opts = {})
+          datatable._bulk_actions.push(link_to_bulk_action(title, url, opts.merge('data-bulk-download': true)))
         end
 
         def bulk_action_divider
-          datatable._bulk_actions.push(content_tag(:li, '', class: 'divider', role: 'separator'))
+          datatable._bulk_actions.push(content_tag(:div, '', class: 'dropdown-divider'))
         end
 
         def bulk_action_content(&block)
@@ -22,26 +22,19 @@ module Effective
         private
 
         # We can't let any data-method be applied to the link, or jquery_ujs does the wrong thing with it
-        def link_to_bulk_action(*args)
-          args.map! do |arg|
-            if arg.kind_of?(Hash)
-              data_method = (
-                arg.delete(:'data-method') ||
-                arg.delete('data-method') ||
-                (arg[:data] || {}).delete('method') ||
-                (arg[:data] || {}).delete(:method)
-              )
-
-              # But if the data-method was :get, we add bulk-actions-get-link = true
-              if data_method.to_s == 'get'
-                arg[:data].present? ? arg[:data]['bulk-actions-get'] = true : arg['data-bulk-actions-get'] = true
-              end
-            end
-
-            arg
+        def link_to_bulk_action(title, url, opts = {})
+
+          # Transform data: { ... } hash into 'data-' keys
+          if (data = opts.delete(:data))
+            data.each { |k, v| opts["data-#{k}"] ||= v }
           end
 
-          link_to(*args)
+          verbs = {'DELETE' => 'DELETE', 'GET' => 'GET'}
+          opts['data-ajax-method'] = verbs[opts.delete('data-method').to_s.upcase] || 'POST'
+
+          opts[:class] = [opts[:class], 'dropdown-item'].compact.join(' ')
+
+          content_tag(:li, link_to(title, url, opts))
         end
 
       end

data/app/models/effective/effective_datatable/dsl/datatable.rb

@@ -3,6 +3,11 @@ module Effective
     module Dsl
       module Datatable
         # Instance Methods inside the datatable do .. end block
+        def length(length)
+          raise 'length must be 5, 10, 25, 50, 100, 250, 500, :all' unless [5, 10, 25, 50, 100, 250, 500, :all].include?(length)
+          datatable.state[:length] ||= (length == :all ? 9999999 : length)
+        end
+
         def order(name, dir = nil)
           raise 'order direction must be :asc or :desc' unless [nil, :asc, :desc].include?(dir)
 
@@ -10,9 +15,13 @@ module Effective
           datatable.state[:order_dir] ||= dir
         end
 
-        def length(length)
-          raise 'length must be 5, 10, 25, 50, 100, 250, 500, :all' unless [5, 10, 25, 50, 100, 250, 500, :all].include?(length)
-          datatable.state[:length] ||= (length == :all ? 9999999 : length)
+        def reorder(name, dir = nil)
+          raise 'order direction must be :asc or :desc' unless [nil, :asc, :desc].include?(dir)
+
+          datatable.state[:order_name] = :_reorder
+          datatable.state[:order_dir] = dir
+
+          reorder_col(name)
         end
 
         # A col has its internal values sorted/searched before the block is run
@@ -25,7 +34,7 @@ module Effective
           name = name.to_sym unless name.to_s.include?('.')
 
           datatable._columns[name] = Effective::DatatableColumn.new(
-            action: action,  # resource columns only
+            action: action,
             as: as,
             compute: nil,
             col_class: col_class,
@@ -53,7 +62,7 @@ module Effective
           name = name.to_sym unless name.to_s.include?('.')
 
           datatable._columns[name] = Effective::DatatableColumn.new(
-            action: action, # Resource columns only
+            action: action,
             as: as,
             compute: (compute if block_given?),
             col_class: col_class,
@@ -73,8 +82,48 @@ module Effective
           )
         end
 
-        def bulk_actions_col(col_class: nil, partial: nil, partial_as: nil, responsive: 5000)
-          raise 'You can only have one bulk actions column' if datatable.columns[:_bulk_actions].present?
+        def actions_col(btn_class: nil, col_class: nil, inline: nil, partial: nil, partial_as: nil, actions_partial: nil, responsive: 5000, visible: true, **actions, &format)
+          raise 'You can only have one actions column' if datatable.columns[:_actions].present?
+
+          datatable._columns[:_actions] = Effective::DatatableColumn.new(
+            action: false,
+            as: :actions,
+            compute: nil,
+            btn_class: (btn_class || 'btn-sm btn-outline-primary'),
+            col_class: col_class,
+            format: (format if block_given?),
+            index: nil,
+            inline: (inline.nil? ? datatable.inline? : inline),
+            label: false,
+            name: :actions,
+            partial: partial,
+            partial_as: partial_as,
+            actions_partial: (actions_partial || :glyphicons),
+            responsive: responsive,
+            search: false,
+            sort: false,
+            sql_column: nil,
+            th: nil,
+            th_append: nil,
+            visible: visible,
+
+            # { approve: false }. These args are passed to effective_resources render_resource_actions
+            actions: actions
+          )
+        end
+
+        def aggregate(name, label: nil, &compute)
+          datatable._aggregates[name.to_sym] = {
+            compute: (compute if block_given?),
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+          }
+        end
+
+        # Called automatically after bulk_actions do ... end
+        # Call again if you want to change the position of the bulk_actions_col
+        def bulk_actions_col(col_class: nil, input_name: nil, partial: nil, partial_as: nil, responsive: 5000)
+          datatable._columns.delete(:_bulk_actions) if datatable.columns[:_bulk_actions]
 
           datatable._columns[:_bulk_actions] = Effective::DatatableColumn.new(
             action: false,
@@ -83,6 +132,7 @@ module Effective
             col_class: col_class,
             format: nil,
             index: nil,
+            input_name: (input_name || 'bulk_actions_resources'),
             label: false,
             name: :bulk_actions,
             partial: partial || '/effective/datatables/bulk_actions_column',
@@ -97,41 +147,33 @@ module Effective
           )
         end
 
-        def actions_col(col_class: nil, partial: nil, partial_as: nil, actions_partial: nil, responsive: 5000, visible: true, **actions, &format)
-          raise 'You can only have one actions column' if datatable.columns[:_actions].present?
+        # Called automatically after reorder
+        # Call again if you want to change the position of the reorder_col
+        def reorder_col(name, col_class: nil, partial: nil, partial_as: nil, sql_column: nil, responsive: 5000)
+          datatable._columns.delete(:_reorder) if datatable.columns[:_reorder]
 
-          datatable._columns[:_actions] = Effective::DatatableColumn.new(
+          datatable._columns[:_reorder] = Effective::DatatableColumn.new(
             action: false,
-            as: :actions,
+            as: :reorder,
             compute: nil,
             col_class: col_class,
-            format: (format if block_given?),
+            format: nil,
             index: nil,
             label: false,
-            name: :actions,
-            partial: partial,
+            name: :reorder,
+            partial: partial || '/effective/datatables/reorder_column',
             partial_as: partial_as,
-            actions_partial: (actions_partial || :glyphicons),
+            reorder: name,
             responsive: responsive,
             search: false,
-            sort: false,
-            sql_column: nil,
+            sort: true,
+            sql_column: (sql_column || name),
             th: nil,
             th_append: nil,
-            visible: visible,
-
-            # { approve: false }. These args are passed to effective_resources render_resource_actions
-            actions: actions
+            visible: false
           )
         end
 
-        def aggregate(name, label: nil, &compute)
-          datatable._aggregates[name.to_sym] = {
-            compute: (compute if block_given?),
-            label: label || name.to_s.titleize,
-            name: name.to_sym,
-          }
-        end
       end
     end
   end

data/app/models/effective/effective_datatable/dsl/filters.rb

@@ -5,7 +5,7 @@ module Effective
         def filter(name = nil, value = :_no_value, as: nil, label: nil, parse: nil, required: false, **input_html)
           return datatable.filter if (name == nil && value == :_no_value) # This lets block methods call 'filter' and get the values
 
-          raise 'expected second argument to be a value' if value == :_no_value
+          raise 'expected second argument to be a value. the default value for this filter.' if value == :_no_value
           raise 'parse must be a Proc' if parse.present? && !parse.kind_of?(Proc)
 
           # Merge search
@@ -13,15 +13,23 @@ module Effective
             input_html = input_html.merge(input_html[:search])
           end
 
+          # Try to guess as value
+          as ||= (
+            if input_html.key?(:collection)
+              :select
+            elsif value != nil
+              Effective::Attribute.new(value).type
+            end
+          ) || :text
+
           datatable._filters[name.to_sym] = {
             value: value,
             as: as,
-            label: label || (label == false ? false : name.to_s.titleize),
+            label: label,
             name: name.to_sym,
             parse: parse,
             required: required,
-            input_html: input_html.merge({ value: value })
-          }
+          }.compact.reverse_merge(input_html)
         end
 
         def scope(name = nil, *args, default: nil, label: nil)

data/app/models/effective/effective_datatable/format.rb

@@ -84,10 +84,7 @@ module Effective
         when :actions
           raise("please use actions_col instead of col(#{name}, as: :actions)")
         when :boolean
-          case value
-          when true   ; 'Yes'
-          when false  ; 'No'
-          end
+          view.t("effective_datatables.boolean_#{value}")
         when :currency
           view.number_to_currency(value)
         when :date

data/app/models/effective/effective_datatable/params.rb

@@ -7,8 +7,13 @@ module Effective
       def datatables_ajax_request?
         return @_datatables_ajax_request unless @_datatables_ajax_request.nil?
 
-        @_datatables_ajax_request =
-          (view && view.params[:draw] && view.params[:columns] && cookie_keys.include?(view.params[:cookie])) == true
+        @_datatables_ajax_request = (view.present? && view.params.key?(:draw) && view.params.key?(:columns))
+      end
+
+      def datatables_inline_request?
+        return @_datatables_inline_request unless @_datatables_inline_request.nil?
+
+        @_datatables_inline_request = (view.present? && view.params[:_datatable_id].to_s.split('-')[0...-1] == to_param.split('-')[0...-1])
       end
 
       def params
@@ -20,7 +25,7 @@ module Effective
       end
 
       def filter_params
-        params.select { |name, value| _filters.key?(name.to_sym) }
+        params.select { |name, value| _filters.key?(name.to_sym) && name != 'id' }
       end
 
       def scope_param
@@ -29,7 +34,7 @@ module Effective
 
       def search_params
         params.select do |name, value|
-          columns.key?(name) && (name != :id) && !value.kind_of?(Hash) && value.class.name != 'ActionController::Parameters'.freeze
+          columns.key?(name) && ![:id, :action].include?(name) && !value.kind_of?(Hash) && value.class.name != 'ActionController::Parameters'.freeze
         end
       end
     end

data/app/models/effective/effective_datatable/resource.rb

@@ -8,7 +8,11 @@ module Effective
       end
 
       def controller_namespace
-        @attributes[:_n]
+        @attributes[:namespace]
+      end
+
+      def association_macros
+        [:belongs_to, :belongs_to_polymorphic, :has_many, :has_and_belongs_to_many, :has_one]
       end
 
       private
@@ -23,99 +27,129 @@ module Effective
       def load_resource!
         load_effective_resource!
 
-        if active_record_collection?
-          columns.each do |name, opts|
+        load_active_record_collection!
+        load_active_record_array_collection!
+        load_array_collection!
 
-            # col 'comments.title'
-            if name.kind_of?(String) && name.include?('.')
-              raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
+        load_resource_columns!
+        load_resource_belongs_tos!
+        load_resource_search!
+      end
 
-              (associated, field) = name.split('.').first(2)
+      def load_effective_resource!
+        @effective_resource = if active_record_collection?
+          Effective::Resource.new(collection_class, namespace: controller_namespace)
+        end
+      end
 
-              unless resource.macros.include?(resource.sql_type(associated))
-                raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{resource}'."
-              end
+      def load_active_record_collection!
+        return unless active_record_collection?
 
-              joins_values = (collection.joins_values + collection.left_outer_joins_values)
+        columns.each do |name, opts|
+          # col 'comments.title'
+          if name.kind_of?(String) && name.include?('.')
+            raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
 
-              unless joins_values.include?(associated.to_sym)
-                raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
-              end
+            (associated, field) = name.split('.').first(2)
 
-              opts[:resource] = Effective::Resource.new(resource.associated(associated), namespace: controller_namespace)
+            unless association_macros.include?(effective_resource.sql_type(associated))
+              raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{effective_resource}'."
+            end
 
-              if opts[:resource].column(field)
-                opts[:as] ||= opts[:resource].sql_type(field)
-                opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
-                opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+            joins_values = (collection.joins_values + collection.left_outer_joins_values)
 
-                opts[:resource].sort_column = field
-                opts[:resource].search_columns = field
-              end
+            unless joins_values.include?(associated.to_sym)
+              raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
+            end
 
-              opts[:resource_field] = field
+            opts[:resource] = Effective::Resource.new(effective_resource.associated(associated), namespace: controller_namespace)
 
-              next
+            if opts[:resource].column(field)
+              opts[:as] ||= opts[:resource].sql_type(field)
+              opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
+              opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+
+              opts[:resource].sort_column = field
+              opts[:resource].search_columns = field
             end
 
-            # Regular fields
-            opts[:as] ||= resource.sql_type(name)
-            opts[:sql_column] = resource.sql_column(name) if opts[:sql_column].nil?
+            opts[:resource_field] = field
+
+            next
+          end
+
+          # Regular fields
+          opts[:as] ||= effective_resource.sql_type(name)
+          opts[:sql_column] = effective_resource.sql_column(name) if opts[:sql_column].nil?
 
-            case opts[:as]
-            when *resource.macros
-              opts[:resource] ||= Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
+          case opts[:as]
+          when *association_macros
+            opts[:resource] ||= Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
+            opts[:sql_column] = name if opts[:sql_column].nil?
+          when Class
+            if opts[:as].ancestors.include?(ActiveRecord::Base)
+              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+              opts[:as] = :resource
               opts[:sql_column] = name if opts[:sql_column].nil?
-            when Class
-              if opts[:as].ancestors.include?(ActiveRecord::Base)
-                opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
-                opts[:as] = :resource
-                opts[:sql_column] = name if opts[:sql_column].nil?
-              end
-            when :effective_addresses
-              opts[:resource] = Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
-              opts[:sql_column] = :effective_addresses
-            when :effective_roles
-              opts[:sql_column] = :effective_roles
-            when :string  # This is the fallback
-              # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
-              opts[:sql_as_column] = true if (resource.table && resource.column(name).blank?)
             end
+          when :effective_addresses
+            opts[:resource] = Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
+            opts[:sql_column] = :effective_addresses
+          when :effective_roles
+            opts[:sql_column] = :effective_roles
+          when :string  # This is the fallback
+            # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
+            opts[:sql_as_column] = true if (effective_resource.table && effective_resource.column(name).blank?)
+          end
 
-            if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
-              opts[:sql_as_column] = true
-            end
+          if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
+            opts[:sql_as_column] = true
           end
         end
+      end
 
-        if array_collection?
-          row = collection.first
+      def load_active_record_array_collection!
+        return unless active_record_array_collection?
+      end
 
-          columns.each do |name, opts|
-            if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
-              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+      def load_array_collection!
+        return unless array_collection?
+
+        row = collection.first
+
+        columns.each do |name, opts|
+          if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
+            opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+            opts[:as] = :resource
+          elsif opts[:as] == nil && row.present?
+            if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
+              opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
               opts[:as] = :resource
-            elsif opts[:as] == nil
-              if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
-                opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
-                opts[:as] = :resource
-              end
             end
           end
         end
+      end
 
+      def load_resource_columns!
         columns.each do |name, opts|
           opts[:as] ||= :string
           opts[:as] = :email if (opts[:as] == :string && name.to_s.end_with?('email'))
 
+          if opts[:action]
+            opts[:resource] ||= effective_resource
+          end
+
           if opts[:resource] && !opts[:resource_field] && opts[:as] != :effective_addresses
             opts[:partial] ||= '/effective/datatables/resource_column'
           end
 
-          opts[:col_class] = "col-#{opts[:as]} col-#{name.to_s.parameterize} #{opts[:col_class]}".strip
+          opts[:col_class] = [
+            "col-#{opts[:as]}",
+            "col-#{name.to_s.parameterize}",
+            ('colvis-default' if opts[:visible]),
+            opts[:col_class].presence
+          ].compact.join(' ')
         end
-
-        load_resource_search!
       end
 
       def load_resource_search!
@@ -127,7 +161,7 @@ module Effective
           when Symbol
             opts[:search] = { as: opts[:search] }
           when Array, ActiveRecord::Relation
-            opts[:search] = { collection: opts[:search] }
+            opts[:search] = { as: :select, collection: opts[:search] }
           when Hash
             # Nothing
           else
@@ -136,31 +170,35 @@ module Effective
 
           search = opts[:search]
 
+          # Parameterize collection
           if search[:collection].kind_of?(ActiveRecord::Relation)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
           elsif search[:collection].kind_of?(Array) && search[:collection].first.kind_of?(ActiveRecord::Base)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
-          elsif search[:collection].kind_of?(Array)
-            search[:collection].each { |obj| obj[1] = 'nil' if obj[1] == nil }
-          elsif search[:collection].kind_of?(Hash)
-            search[:collection].each { |k, v| search[:collection][k] = 'nil' if v == nil }
           end
 
+          search[:as] ||= :select if search.key?(:collection)
+          search[:fuzzy] ||= true unless search.key?(:fuzzy)
           search[:value] ||= search.delete(:selected) if search.key?(:selected)
 
-          search[:as] ||= :select if (search.key?(:collection) && opts[:as] != :belongs_to_polymorphic)
-
-          search[:fuzzy] = true unless search.key?(:fuzzy)
+          # Merge with defaults
+          search_resource = [opts[:resource], effective_resource, fallback_effective_resource].compact
+          search_resource = search_resource.find { |res| res.klass.present? } || search_resource.first
 
           if array_collection? && opts[:resource].present?
-            search.reverse_merge!(resource.search_form_field(name, collection.first[opts[:index]]))
+            search.reverse_merge!(search_resource.search_form_field(name, collection.first[opts[:index]]))
           elsif search[:as] != :string
-            search.reverse_merge!(resource.search_form_field(name, opts[:as]))
+            search.reverse_merge!(search_resource.search_form_field(name, opts[:as]))
+          end
+
+          # Assign default include_null
+          if search[:as] == :select && !search.key?(:include_null)
+            search[:include_null] = true
           end
         end
       end
 
-      def apply_belongs_to_attributes!
+      def load_resource_belongs_tos!
         return unless active_record_collection?
 
         changed = attributes.select do |attribute, value|
@@ -168,10 +206,27 @@ module Effective
           next unless attribute.ends_with?('_id')
 
           associated = attribute.gsub(/_id\z/, '').to_sym  # Replace last _id
-          next unless columns[associated] && columns[associated][:as] == :belongs_to
 
-          @_collection = @_collection.where(attribute => value)
-          columns.delete(associated)
+          next unless columns[associated]
+
+          if columns[associated][:as] == :belongs_to
+            if @_collection_apply_belongs_to && !@_collection.where_values_hash.include?(attribute)
+              @_collection = @_collection.where(attribute => value)
+            end
+
+            columns.delete(associated)
+          elsif columns[associated][:as] == :belongs_to_polymorphic
+            associated_type = attributes["#{associated}_type".to_sym] || raise("Expected #{associated}_type attribute to be present when #{associated}_id is present on a polymorphic belongs to")
+
+            if @_collection_apply_belongs_to
+              if !@_collection.where_values_hash.include?(attribute) && !@_collection.where_values_hash.include?("#{associated}_type")
+                @_collection = @_collection.where(attribute => value).where("#{associated}_type" => associated_type)
+              end
+            end
+
+            columns.delete(associated)
+          end
+
         end.present?
 
         load_columns! if changed