effective_datatables 2.12.2 → 3.0.0

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

@@ -7,24 +7,6 @@ module Effective
         collection
       end
 
-      # Override this function to perform custom searching on a column
-      def search_column(collection, table_column, search_term, sql_column_or_index)
-        if table_column[:array_column]
-          array_tool.search_column_with_defaults(collection, table_column, search_term, sql_column_or_index)
-        else
-          table_tool.search_column_with_defaults(collection, table_column, search_term, sql_column_or_index)
-        end
-      end
-
-      # Override this function to perform custom ordering on a column
-      # direction will be :asc or :desc
-      def order_column(collection, table_column, direction, sql_column_or_index)
-        if table_column[:array_column]
-          array_tool.order_column_with_defaults(collection, table_column, direction, sql_column_or_index)
-        else
-          table_tool.order_column_with_defaults(collection, table_column, direction, sql_column_or_index)
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,34 @@
+module Effective
+  module EffectiveDatatable
+    module Params
+
+      private
+
+      def datatables_ajax_request?
+        view && view.params[:draw] && view.params[:columns] && view.params[:id] == to_param
+      end
+
+      def params
+        return {} unless view.present?
+        @params ||= {}.tap do |params|
+          Rack::Utils.parse_query(URI(view.request.referer.presence || '/').query).each { |k, v| params[k.to_sym] = v }
+          view.params.each { |k, v| params[k.to_sym] = v }
+        end
+      end
+
+      def filter_params
+        params.select { |name, value| _filters.key?(name.to_sym) }
+      end
+
+      def scope_param
+        params[:scope].to_sym if params.key?(:scope)
+      end
+
+      def search_params
+        params.select do |name, value|
+          columns.key?(name) && (name != :id) && !value.kind_of?(Hash) && value.class.name != 'ActionController::Parameters'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Effective
+  module EffectiveDatatable
+    module Resource
+
+      def admin_namespace?
+        controller_namespace == 'admin'
+      end
+
+      def controller_namespace
+        @attributes[:controller_namespace]
+      end
+
+      private
+
+      # This looks at all the columns and figures out the as:
+      def load_resource!
+        @resource = Effective::Resource.new(collection_class, namespace: controller_namespace)
+
+        if active_record_collection?
+          columns.each do |name, opts|
+            opts[:as] ||= resource.sql_type(name)
+            opts[:sql_column] = (resource.sql_column(name) || false) if opts[:sql_column].nil?
+
+            case opts[:as]
+            when *resource.macros
+              opts[:resource] = Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
+              opts[:sql_column] ||= name
+            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
+              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
+              if (resource.table && resource.column(name).blank?)
+                opts[:sql_as_column] = true
+              end
+            end
+          end
+        end
+
+        if 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
+              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
+
+        columns.each do |name, opts|
+          opts[:as] ||= :string
+          opts[:as] = :email if (opts[:as] == :string && name == :email)
+
+          opts[:partial] ||= '/effective/datatables/resource_column' if (opts[:resource] && opts[:as] != :effective_addresses)
+
+          opts[:col_class] = "col-#{opts[:as]} col-#{name.to_s.parameterize} #{opts[:col_class]}".strip
+        end
+
+        load_resource_search!
+      end
+
+      def load_resource_search!
+        columns.each do |name, opts|
+
+          case opts[:search]
+          when false
+            opts[:search] = { as: :null }; next
+          when Symbol
+            opts[:search] = { as: opts[:search] }
+          when Array, ActiveRecord::Relation
+            opts[:search] = { collection: opts[:search] }
+          end
+
+          search = opts[:search]
+
+          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].each { |obj| obj[1] = 'nil' if obj[1] == nil }
+          end
+
+          search[:as] ||= :select if (search.key?(:collection) && opts[:as] != :belongs_to_polymorphic)
+          search[:fuzzy] = true unless search.key?(:fuzzy)
+
+          if array_collection? && opts[:resource].present?
+            search.reverse_merge!(resource.search_form_field(name, collection.first[opts[:index]]))
+          else
+            search.reverse_merge!(resource.search_form_field(name, opts[:as]))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+module Effective
+  module EffectiveDatatable
+    module State
+
+      def scope
+        state[:scope]
+      end
+      alias_method :current_scope, :scope
+      alias_method :scopes, :scope
+
+      def filter
+        state[:filter]
+      end
+      alias_method :filters, :filter
+
+      def display_length
+        state[:length]
+      end
+
+      def display_start
+        state[:start]
+      end
+
+      def order_direction
+        state[:order_dir]
+      end
+
+      def order_index
+        state[:order_index]
+      end
+
+      def order_name
+        state[:order_name]
+      end
+
+      def search
+        state[:search]
+      end
+
+      def page
+        state[:start].to_i / state[:length] + 1
+      end
+
+      def per_page
+        state[:length]
+      end
+
+      private
+
+      # This is called first.  Our initial state is set.
+      def initial_state
+        {
+          filter: {},
+          length: nil,
+          order_name: nil,
+          order_dir: nil,
+          order_index: nil,
+          params: 0,
+          scope: nil,
+          start: 0,
+          search: {},
+          visible: {}
+        }
+      end
+
+      def load_filters!
+        state[:filter] = _filters.inject({}) { |h, (name, opts)| h[name] = opts[:value]; h }
+        state[:scope] = _scopes.find { |_, opts| opts[:default] }.try(:first) || _scopes.keys.first
+      end
+
+      def load_filter_params!
+        filter_params.each { |name, value| state[:filter][name] = parse_filter_value(_filters[name], value) }
+        state[:scope] = scope_param if scope_param
+      end
+
+      def fill_empty_filters!
+        state[:filter].each do |name, value|
+          next unless (value.nil? && _filters[name][:required])
+          state[:filter][name] = _filters[name][:value]
+        end
+      end
+
+      def load_state!
+        if datatables_ajax_request?
+          load_filter_params!
+          load_ajax_state!
+        elsif cookie.present? && cookie[:state][:params] == params.length
+          load_cookie_state!
+        else
+          # Nothing to do for default state
+        end
+
+        load_filter_params! unless datatables_ajax_request?
+        fill_empty_filters!
+      end
+
+      def load_ajax_state!
+        state[:length] = params[:length].to_i
+
+        state[:order_dir] = (params[:order]['0'][:dir] == 'desc' ? :desc : :asc)
+        state[:order_index] = params[:order]['0'][:column].to_i
+
+        state[:scope] = _scopes.keys.find { |name| params[:scope] == name.to_s }
+        state[:start] = params[:start].to_i
+
+        state[:search] = {}
+        state[:visible] = {}
+
+        params[:columns].values.each do |params|
+          name = params[:name].to_sym
+
+          if params[:search][:value].present? && !['null'].include?(params[:search][:value])
+            state[:search][name] = params[:search][:value]
+          end
+
+          state[:visible][name] = (params[:visible] == 'true')
+        end
+
+        (params[:filter] || {}).each do |name, value|
+          name = name.to_sym
+          raise "unexpected filter name: #{name}" unless _filters.key?(name)
+
+          state[:filter][name] = parse_filter_value(_filters[name], value)
+        end
+
+        state[:params] = cookie[:state][:params]
+      end
+
+      def load_cookie_state!
+        @state = cookie[:state]
+      end
+
+      def load_columns!
+        state[:length] ||= EffectiveDatatables.default_length
+
+        if columns.present?
+          if order_index.present?
+            state[:order_name] = columns.keys[order_index]
+          end
+
+          state[:order_name] ||= columns.find { |name, opts| opts[:sort] }.first
+          raise "order column :#{order_name} must exist as a col or val" unless columns[order_name]
+
+          state[:order_index] = columns[order_name][:index]
+        end
+
+        # Set default order direction
+        state[:order_dir] ||= ['_at', '_on', 'date'].any? { |str| order_name.to_s.end_with?(str) } ? :desc : :asc
+
+        if state[:search].blank?
+          columns.each do |name, opts|
+            state[:search][name] = opts[:search][:value] if opts[:search].kind_of?(Hash) && opts[:search].key?(:value)
+          end
+        end
+
+        columns.each do |name, opts|
+          state[:visible][name] = opts[:visible] unless state[:visible].key?(name)
+        end
+
+        unless datatables_ajax_request?
+          search_params.each { |name, value| state[:search][name] = value }
+          state[:params] = params.length
+        end
+
+        state[:visible].delete_if { |name, _| columns.key?(name) == false }
+        state[:search].delete_if { |name, _| columns.key?(name) == false }
+      end
+
+      # The incoming value could be from the passed page params or from the AJAX request.
+      # When we parse an incoming filter term for this filter.
+      def parse_filter_value(filter, value)
+        return filter[:parse].call(value) if filter[:parse]
+        Effective::Attribute.new(filter[:value]).parse(value, name: filter[:name])
+      end
+
+    end
+  end
+end

data/app/views/effective/datatables/_actions_column.html.haml

@@ -1,44 +1,11 @@
-:ruby
-  if show_action == :authorize_each
-    show_action = (EffectiveDatatables.authorized?(controller, :show, resource) rescue false)
-  elsif show_action.respond_to?(:call)
-    show_action = instance_exec(resource, &show_action)
-  end
+- if show_path
+  - if show_action == true || (EffectiveDatatables.authorized?(controller, :show, resource) rescue false)
+    = show_icon_to send(show_path, resource.to_param)
 
-  if edit_action == :authorize_each
-    edit_action = (EffectiveDatatables.authorized?(controller, :edit, resource) rescue false)
-  elsif edit_action.respond_to?(:call)
-    edit_action = instance_exec(resource, &edit_action)
-  end
+- if edit_path
+  - if edit_action == true || (EffectiveDatatables.authorized?(controller, :edit, resource) rescue false)
+    = edit_icon_to send(edit_path, resource.to_param)
 
-  if destroy_action == :authorize_each
-    destroy_action = (EffectiveDatatables.authorized?(controller, :destroy, resource) rescue false)
-  elsif destroy_action.respond_to?(:call)
-    destroy_action = instance_exec(resource, &destroy_action)
-  end
-
-  if unarchive_action == :authorize_each
-    unarchive_action = (EffectiveDatatables.authorized?(controller, :unarchive, resource) rescue false)
-  elsif unarchive_action.respond_to?(:call)
-    unarchive_action = instance_exec(resource, &unarchive_action)
-  end
-
-- if show_action && defined?(show_path)
-  = show_icon_to show_path.gsub(':to_param', resource.to_param)
-
-- if edit_action && defined?(edit_path)
-  = edit_icon_to edit_path.gsub(':to_param', resource.to_param)
-
-- if destroy_action && defined?(destroy_path)
-  - if resource.respond_to?(:archived?) && !resource.archived?
-    = archive_icon_to destroy_path.gsub(':to_param', resource.to_param)
-  - elsif resource.respond_to?(:archived?) == false
-    = destroy_icon_to destroy_path.gsub(':to_param', resource.to_param)
-
-- if unarchive_action && defined?(unarchive_path)
-  - if resource.respond_to?(:archived?) && resource.archived?
-    = unarchive_icon_to unarchive_path.gsub(':to_param', resource.to_param)
-
-- if actions_block
-  = capture do
-    - instance_exec(resource, &actions_block)
+- if destroy_path
+  - if destroy_action == true || (EffectiveDatatables.authorized?(controller, :destroy, resource) rescue false)
+    = destroy_icon_to send(destroy_path, resource.to_param)

data/app/views/effective/datatables/_bulk_actions_column.html.haml

@@ -1,2 +1,2 @@
-- id = (resource.public_send(resource_method) rescue resource.object_id)
+- id = (resource.try(:to_param) || resource.try(:id) || resource.object_id)
 = check_box_tag 'bulk_actions_resources[]', id, false, autocomplete: 'off', id: "bulk_actions_resource_#{id}", data: { role: 'bulk-actions-resource' }, onClick: 'event.stopPropagation();'

data/app/views/effective/datatables/_bulk_actions_dropdown.html.haml

@@ -3,9 +3,8 @@
     Bulk Actions
     %span.caret
   %ul.dropdown-menu
-    - if dropdown_block.respond_to?(:call)
-      = capture do
-        - instance_exec(&dropdown_block)
+    - if datatable._bulk_actions.present?
+      = datatable._bulk_actions.join.html_safe
     - else
       %li
         %a{href: '#'} No bulk actions

data/app/views/effective/datatables/_chart.html.haml

@@ -1 +1 @@
-.effective-datatables-chart{id: "#{chart[:name].to_s.parameterize}-chart-#{Time.zone.now.nsec}", data: {name: chart[:name], type: chart[:type], options: chart[:options].to_json, data: chart[:data].to_json}}
+.effective-datatables-chart{id: "#{chart[:name].to_s.parameterize}-chart-#{Time.zone.now.nsec}", data: { name: chart[:name], as: chart[:as], options: chart[:options].to_json, data: chart_data.to_json }}

data/app/views/effective/datatables/_datatable.html.haml

@@ -1,36 +1,18 @@
-:ruby
-  effective_datatable_params = {
-    id: "#{datatable.to_param}-table-#{Time.zone.now.nsec}",
-    class: "#{datatable.table_html_class}",
-    data: {
-      'effective-form-inputs' => defined?(EffectiveFormInputs),
-      'bulk-actions' => datatable_bulk_actions(datatable),
-      'columns' => datatable_columns(datatable),
-      'input-js-options' => local_assigns[:input_js_options],
-      'simple' => datatable.simple?.to_s,
-      'source' => effective_datatables.datatable_path(datatable, {format: 'json'}.merge(attributes: datatable.attributes)).chomp('?'),
-      'default-order' => datatable_default_order(datatable),
-      'display-entries' => datatable.display_entries,
-      'display-records' => (datatable.to_json[:recordsFiltered] || 0),
-      'total-records' => (datatable.to_json[:recordsTotal] || 0)
-    }
-  }
-
 %table.effective-datatable{effective_datatable_params}
   %thead
-    - if datatable.table_columns.any? { |_, opts| opts[:th].present? } == false
+    - if datatable.columns.any? { |_, opts| opts[:th].present? } == false
       %tr
-        - datatable.table_columns.each do |name, opts|
+        - datatable.columns.each do |name, opts|
           %th= opts[:label] || name
     - else
-      - max_depth = datatable.table_columns.map { |_, opts| opts[:th].try(:[], :depth) || 0 }.max
+      - max_depth = datatable.columns.map { |_, opts| opts[:th].try(:[], :depth) || 0 }.max
       - [*0..max_depth].each do |depth|
         %tr
-          - table_columns = datatable.table_columns.select { |_, opts| (opts[:th].try(:[], :depth) || 0) == depth }
-          - table_columns.each do |name, opts|
+          - columns = datatable.columns.select { |_, opts| (opts[:th].try(:[], :depth) || 0) == depth }
+          - columns.each do |name, opts|
             %th{(opts[:th] || {}).merge(title: (opts[:label] || name))}
               = opts[:label] || name
-            - (opts[:append_th] || []).each do |faux_col|
+            - (opts[:th_append] || []).each do |faux_col|
               %th{(faux_col[:th] || {}).merge(title: faux_col[:label])}
                 = faux_col[:label]
 
@@ -40,7 +22,7 @@
         - row.each do |col|
           %td= col.to_s.html_safe
 
-  - if datatable.aggregates.present?
+  - if datatable.to_json[:aggregates].present?
     %tfoot
       - datatable.to_json[:aggregates].each do |row|
         %tr