effective_datatables 4.7.16 → 4.15.1

data/app/assets/javascripts/effective_datatables/initialize.js.coffee

@@ -5,6 +5,9 @@ initializeDataTables = (target) ->
     buttons_export_columns = options['buttons_export_columns'] || ':not(.col-actions)'
     reorder = datatable.data('reorder')
 
+    if datatable.data('inline') && datatable.closest('form').length > 0
+      console.error('inline datatable cannot work inside a form')
+
     if options['buttons'] == false
       options['buttons'] = []
 
@@ -49,7 +52,7 @@ initializeDataTables = (target) ->
       displayStart: datatable.data('display-start')
       iDisplayLength: datatable.data('display-length')
       language: datatable.data('language')
-      lengthMenu: [[5, 10, 25, 50, 100, 250, 500, 9999999], ['5', '10', '25', '50', '100', '250', '500', 'All']]
+      lengthMenu: [[5, 10, 25, 50, 100, 250, 500, 9999999], ['5', '10', '25', '50', '100', '250', '500', datatable.data('all-label')]]
       order: datatable.data('display-order')
       processing: true
       responsive: true
@@ -77,7 +80,7 @@ initializeDataTables = (target) ->
               filter_name = name.replace('filters[', '').substring(0, name.length-9)
 
               params['filter'][filter_name] = $form.find("input[name='#{name}']:checked").val()
-              
+
             else if $input.attr('id')
               filter_name = $input.attr('id').replace('filters_', '')
               params['filter'][filter_name] = $input.val()
@@ -109,14 +112,8 @@ initializeDataTables = (target) ->
       $table = $(api.table().node())
       $buttons = $table.closest('.dataTables_wrapper').children().first().find('.dt-buttons')
 
-      if $table.data('reset')
-        $buttons.prepend($table.data('reset'))
-
-      if $table.data('reorder')
-        $buttons.prepend($table.data('reorder'))
-
-      if $table.data('bulk-actions')
-        $buttons.prepend($table.data('bulk-actions'))
+      if $table.data('buttons-html')
+        $buttons.prepend($table.data('buttons-html'))
 
     drawAggregates = ($table, aggregates) ->
       $tfoot = $table.find('tfoot').first()
@@ -131,7 +128,7 @@ initializeDataTables = (target) ->
       if typeof(google) != 'undefined' && typeof(google.visualization) != 'undefined'
         $.each charts, (name, data) =>
           $(".effective-datatables-chart[data-name='#{name}']").each (_, obj) =>
-            chart = new google.visualization[data['type']](obj)
+            chart = new google.visualization[data['as']](obj)
             chart.draw(google.visualization.arrayToDataTable(data['data']), data['options'])
 
     # Appends the search html, stored in the column definitions, into each column header
@@ -162,14 +159,23 @@ initializeDataTables = (target) ->
           $input.on 'change', (event) -> dataTableSearch($(event.currentTarget))
         else if $input.is('input')
           $input.delayedChange ($input) -> dataTableSearch($input)
-          $input.on('paste', -> dataTableSearch($input))
 
     # Do the actual search
     dataTableSearch = ($input) ->   # This is the function called by a select or input to run the search
       return if $input.is(':invalid')
 
       table = $input.closest('table.dataTable')
-      table.DataTable().column("#{$input.data('column-name')}:name").search($input.val()).draw()
+
+      value = $input.val()
+
+      if Array.isArray(value)
+        # Nothing
+      else if value.startsWith('"') && value.endsWith('"')
+        value = value.substring(1, value.length-1)
+      else
+        value = $.trim(value)
+
+      table.DataTable().column("#{$input.data('column-name')}:name").search(value).draw()
 
     if reorder
       init_options['rowReorder'] = { selector: 'td.col-_reorder', snapX: true, dataSrc: datatable.data('reorder-index') }
@@ -188,6 +194,7 @@ initializeDataTables = (target) ->
 
     table.addClass('initialized')
     table.children('thead').trigger('effective-bootstrap:initialize')
+    table.children('thead').find('input[autofocus]').first().focus()
     true
 
 destroyDataTables = ->
@@ -201,3 +208,5 @@ $(document).on 'page:change', -> initializeDataTables()
 $(document).on 'turbolinks:load', -> initializeDataTables()
 $(document).on 'turbolinks:render', -> initializeDataTables()
 $(document).on 'turbolinks:before-cache', -> destroyDataTables()
+$(document).on 'turbo:load', -> initializeDataTables()
+$(document).on 'turbo:before-cache', -> destroyDataTables()

data/app/assets/javascripts/effective_datatables/inline_crud.js.coffee

@@ -1,15 +1,34 @@
 # To achieve inline crud, we use rails' data-remote links, and override their behaviour when inside a datatable
 # This works with EffectiveForm.remote_form which is part of the effective_bootstrap gem.
 
-# We click the New/Edit/Action button from the col-actions
-$(document).on 'ajax:beforeSend', '.dataTables_wrapper .col-actions', (e, xhr, settings) ->
-  $action = $(e.target)
-  $table = $(e.target).closest('table')
+# https://github.com/rails/jquery-ujs/wiki/ajax
+# https://edgeguides.rubyonrails.org/working_with_javascript_in_rails.html#rails-ujs-event-handlers
+
+$(document).on 'ajax:before', '.dataTables_wrapper .col-actions', (event) ->
+  $action = $(event.target)
+  $table = $(event.target).closest('table')
 
   return true if ('' + $action.data('inline')) == 'false'
 
-  $params = $.param({_datatable_id: $table.attr('id'), _datatable_attributes: $table.data('attributes'), _datatable_action: true })
-  settings.url += (if settings.url.indexOf('?') == -1 then '?' else '&') + $params
+  $params = $.param(
+    {
+      _datatable_id: $table.attr('id'),
+      _datatable_attributes: $table.data('attributes'),
+      _datatable_action: true
+    }
+  )
+
+  $action.attr('data-params', $params)
+  true
+
+# We click the New/Edit/Action button from the col-actions
+$(document).on 'ajax:beforeSend', '.dataTables_wrapper .col-actions', (event, xhr, settings) ->
+  [xhr, settings] = event.detail if event.detail # rails/ujs
+
+  $action = $(event.target)
+  $table = $(event.target).closest('table')
+
+  return true if ('' + $action.data('inline')) == 'false'
 
   if $action.closest('.effective-datatables-inline-row,table.dataTable').hasClass('effective-datatables-inline-row')
     # Nothing.
@@ -22,6 +41,8 @@ $(document).on 'ajax:beforeSend', '.dataTables_wrapper .col-actions', (e, xhr, s
 
 # We have either completed the resource action, or fetched the inline form to load.
 $(document).on 'ajax:success', '.dataTables_wrapper .col-actions', (event, data) ->
+  [data, status, xhr] = event.detail if event.detail # rails/ujs
+
   $action = $(event.target)
 
   return true if ('' + $action.data('inline')) == 'false'
@@ -54,12 +75,22 @@ $(document).on 'ajax:error', '.dataTables_wrapper', (event) ->
   EffectiveForm.remote_form_flash = ''
   true
 
-# Submitting an inline datatables form
-$(document).on 'ajax:beforeSend', '.dataTables_wrapper .col-inline-form', (e, xhr, settings) ->
-  $table = $(e.target).closest('table')
+## Now for the fetched form. We add the datatables params attributes
+
+$(document).on 'ajax:before', '.dataTables_wrapper .col-inline-form', (event) ->
+  $action = $(event.target)
+  $form = $action.closest('form')
+  $table = $action.closest('table')
+
+  if $form.find('input[name=_datatable_id]').length == 0
+    $('<input>').attr(
+      {type: 'hidden', name: '_datatable_id', value: $table.attr('id')}
+    ).appendTo($form)
 
-  $params = $.param({_datatable_id: $table.attr('id'), _datatable_attributes: $table.data('attributes') })
-  settings.url += (if settings.url.indexOf('?') == -1 then '?' else '&') + $params
+  if $form.find('input[name=_datatable_attributes]').length == 0
+    $('<input>').attr(
+      {type: 'hidden', name: '_datatable_attributes', value: $table.data('attributes')}
+    ).appendTo($form)
 
   true
 
@@ -92,7 +123,6 @@ beforeNew = ($action) ->
 
   # Append spinner and show Processing
   $th.append($table.data('spinner'))
-  $table.DataTable().flash()
   $table.one 'draw.dt', (event) ->
     $th.find('a').show().siblings('svg').remove() if event.target == event.currentTarget
 
@@ -121,7 +151,6 @@ beforeEdit = ($action) ->
 
   # Append spinner and show Processing
   $td.append($table.data('spinner'))
-  $table.DataTable().flash()
 
 afterEdit = ($action) ->
   $tr = $action.closest('tr')

data/app/assets/javascripts/effective_datatables/reorder.js.coffee

@@ -8,7 +8,14 @@ reorder = (event, diff, edit) ->
   return unless oldNode? && newNode?
 
   url = @context[0].ajax.url.replace('.json', '/reorder.json')
-  data = {'reorder[id]': oldNode.data('reorder-resource'), 'reorder[old]': oldNode.val(), 'reorder[new]': newNode.val(), attributes: $table.data('attributes') }
+
+  data = {
+    'authenticity_token': $('head').find("meta[name='csrf-token']").attr('content'),
+    'reorder[id]': oldNode.data('reorder-resource'),
+    'reorder[old]': oldNode.val(),
+    'reorder[new]': newNode.val(),
+    'attributes': $table.data('attributes')
+  }
 
   @context[0].rowreorder.c.enable = false
 
@@ -40,4 +47,3 @@ $(document).on 'click', '.dataTables_wrapper a.buttons-reorder', (event) ->
     $table.addClass('reordering')
 
   column.visible(!column.visible())
-

data/app/assets/javascripts/effective_datatables/reset.js.coffee

@@ -1,11 +1,32 @@
 $(document).on 'click', '.dataTables_wrapper a.buttons-reset-search', (event) ->
   event.preventDefault() # prevent the click
 
+  # Reset the HTML
   $table = $(event.currentTarget).closest('.dataTables_wrapper').find('table.dataTable').first()
   $thead = $table.children('thead').first()
 
-  $thead.find('input').val('').removeAttr('checked').removeAttr('selected')
+  # Reset all inputs
   $thead.find('select').val('').trigger('change.select2')
 
-  $table.DataTable().search('').columns().search('').draw()
+  $inputs = $thead.find('input')
+  $inputs.val('').removeAttr('checked').removeAttr('selected')
+
+  # Reset delayedChange
+  $.each $inputs, (input) =>
+    $input = $(input)
+    if ($input.delayedChange.oldVal)
+      $input.delayedChange.oldVal = undefined
+
+  # Reset the datatable
+  datatable = $table.DataTable()
+
+  # Reset search
+  datatable.search('').columns().search('')
+
+  # Reset to default visibility
+  $.each $table.data('default-visibility'), (index, visible) =>
+    datatable.column(index).visible(visible, false)
+
+  # Don't pass up the click
+  false
 

data/app/assets/javascripts/vendor/jquery.delayedChange.js

@@ -14,11 +14,10 @@
 
     return this.each(function() {
       var element = $(this);
-      element.keyup(function() {
+      element.on('keyup paste', function() {
         clearTimeout(timer);
         timer = setTimeout(function() {
           var newVal = element.val();
-          newVal = $.trim(newVal);
           if (element.delayedChange.oldVal != newVal) {
             element.delayedChange.oldVal = newVal;
             o.onChange.call(this, element);

data/app/assets/stylesheets/dataTables/dataTables.bootstrap4.scss

@@ -162,9 +162,7 @@ div.dataTables_scrollFoot > .dataTables_scrollFootInner > table {
     text-align: center;
   }
 }
-table.dataTable.table-sm > thead > tr > th {
-  padding-right: 20px;
-}
+
 table.dataTable.table-sm .sorting:before,
 table.dataTable.table-sm .sorting_asc:before,
 table.dataTable.table-sm .sorting_desc:before {

data/app/controllers/effective/datatables_controller.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'csv'
+
 module Effective
   class DatatablesController < ApplicationController
     skip_log_page_views quiet: true if defined?(EffectiveLogging)
@@ -20,6 +24,36 @@ module Effective
       end
     end
 
+    def download
+      @datatable = EffectiveDatatables.find(params[:id], params[:attributes])
+      @datatable.view = view_context
+
+      EffectiveDatatables.authorize!(self, :index, @datatable.collection_class)
+
+      respond_to do |format|
+        format.csv do
+          headers.delete('Content-Length')
+
+          headers['X-Accel-Buffering'] = 'no'
+          headers['Cache-Control'] = 'no-cache'
+          headers["Content-Type"] = @datatable.csv_content_type
+          headers["Content-Disposition"] = %(attachment; filename="#{@datatable.csv_filename}")
+          headers['Last-Modified'] = Time.zone.now.ctime.to_s
+
+          self.response_body = @datatable.csv_stream
+          response.status = 200
+        end
+
+        # format.csv do
+        #   send_data(@datatable.csv_file, filename: @datatable.csv_filename, type: @datatable.csv_content_type, disposition: 'attachment')
+        # end
+
+        format.all do
+          render(status: :unauthorized, body: 'Access Denied')
+        end
+      end
+    end
+
     def reorder
       begin
         @datatable = EffectiveDatatables.find(params[:id], params[:attributes])

data/app/helpers/effective_datatables_controller_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # These are expected to be called by a developer.  They are part of the datatables DSL.
 module EffectiveDatatablesControllerHelper
 

data/app/helpers/effective_datatables_helper.rb

@@ -1,18 +1,29 @@
+# frozen_string_literal: true
+
 # These are expected to be called by a developer.  They are part of the datatables DSL.
 module EffectiveDatatablesHelper
-  def render_datatable(datatable, input_js: {}, buttons: true, charts: true, entries: true, filters: true, inline: false, pagination: true, search: true, simple: false, sort: true)
+  def render_datatable(datatable, input_js: {}, buttons: true, charts: true, download: nil, entries: true, filters: true, inline: false, namespace: nil, pagination: true, search: true, simple: false, sort: true)
     raise 'expected datatable to be present' unless datatable
     raise 'expected input_js to be a Hash' unless input_js.kind_of?(Hash)
 
+    if download.nil?
+      download = (buttons && EffectiveDatatables.download)
+    end
+
     if simple
-      buttons = charts = entries = filters = pagination = search = sort = false
+      buttons = charts = download = entries = filters = pagination = search = sort = false
     end
 
     datatable.attributes[:inline] = true if inline
     datatable.attributes[:sortable] = false unless sort
+    datatable.attributes[:searchable] = false unless search
+    datatable.attributes[:downloadable] = false unless download
+    datatable.attributes[:namespace] = namespace if namespace
 
     datatable.view ||= self
 
+    datatable.state[:length] = 9999999 if simple
+
     unless EffectiveDatatables.authorized?(controller, :index, datatable.collection_class)
       return content_tag(:p, "You are not authorized to view this datatable. (cannot :index, #{datatable.collection_class})")
     end
@@ -40,10 +51,12 @@ module EffectiveDatatablesHelper
       id: datatable.to_param,
       class: html_class,
       data: {
+        'all-label' => I18n.t('effective_datatables.all'),
         'attributes' => EffectiveDatatables.encrypt(datatable.attributes),
         'authenticity-token' => form_authenticity_token,
-        'bulk-actions' => datatable_bulk_actions(datatable),
+        'buttons-html' => datatable_buttons(datatable),
         'columns' => datatable_columns(datatable),
+        'default-visibility' => datatable.default_visibility.to_json,
         'display-length' => datatable.display_length,
         'display-order' => datatable_display_order(datatable),
         'display-records' => datatable.to_json[:recordsFiltered],
@@ -51,8 +64,7 @@ module EffectiveDatatablesHelper
         'inline' => inline.to_s,
         'language' => EffectiveDatatables.language(I18n.locale),
         'options' => input_js.to_json,
-        'reset' => (datatable_reset(datatable) if search),
-        'reorder' => datatable_reorder(datatable),
+        'reorder' => datatable.reorder?.to_s,
         'reorder-index' => (datatable.columns[:_reorder][:index] if datatable.reorder?).to_s,
         'simple' => simple.to_s,
         'spinner' => icon('spinner'), # effective_bootstrap
@@ -61,7 +73,7 @@ module EffectiveDatatablesHelper
       }
     }
 
-    if (charts || filters)
+    retval = if (charts || filters)
       output = ''.html_safe
 
       if charts
@@ -82,6 +94,10 @@ module EffectiveDatatablesHelper
         locals: { datatable: datatable, effective_datatable_params: effective_datatable_params }
       )
     end
+
+    Rails.logger.info("  Rendered datatable #{datatable.class} #{datatable.source_location}")
+
+    retval
   end
 
   def render_inline_datatable(datatable)

data/app/helpers/effective_datatables_private_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # These aren't expected to be called by a developer. They are internal methods.
 module EffectiveDatatablesPrivateHelper
 
@@ -19,32 +21,21 @@ module EffectiveDatatablesPrivateHelper
     end.to_json.html_safe
   end
 
-  def datatable_bulk_actions(datatable)
-    if datatable._bulk_actions.present?
-      render(partial: '/effective/datatables/bulk_actions_dropdown', locals: { datatable: datatable }).gsub("'", '"').html_safe
-    end
-  end
-
   def datatable_display_order(datatable)
     ((datatable.sortable? && datatable.order_index) ? [datatable.order_index, datatable.order_direction] : false).to_json.html_safe
   end
 
-  def datatable_reset(datatable)
-    link_to(content_tag(:span, t('effective_datatables.reset')), '#', class: 'btn btn-link btn-sm buttons-reset-search')
-  end
-
-  def datatable_reorder(datatable)
-    return unless datatable.reorder? && EffectiveDatatables.authorized?(self, :update, datatable.collection_class)
-    link_to(content_tag(:span, t('effective_datatables.reorder')), '#', class: 'btn btn-link btn-sm buttons-reorder', disabled: true)
+  def datatable_buttons(datatable, search: true)
+    render('/effective/datatables/buttons', datatable: datatable, search: search).gsub("'", '"').html_safe
   end
 
   def datatable_new_resource_button(datatable, name, column)
-    return unless column[:inline] && (column[:actions][:new] != false)
+    return unless datatable.inline? && (column[:actions][:new] != false)
 
     action = { action: :new, class: ['btn', column[:btn_class].presence].compact.join(' '), 'data-remote': true }
 
     if column[:actions][:new].kind_of?(Hash) # This might be active_record_array_collection?
-      action = action.merge(column[:actions][:new])
+      actions = action.merge(column[:actions][:new])
 
       effective_resource = (datatable.effective_resource || datatable.fallback_effective_resource)
       klass = (column[:actions][:new][:klass] || effective_resource&.klass || datatable.collection_class)
@@ -68,8 +59,23 @@ module EffectiveDatatablesPrivateHelper
     when :reorder
       content_tag(:span, t('effective_datatables.reorder'), style: 'display: none;')
     else
-      content_tag(:span, opts[:label].presence)
+      label = opts[:label].presence || datatable_human_attribute_name(datatable, name, opts)
+      content_tag(:span, label)
+    end
+  end
+
+  def datatable_human_attribute_name(datatable, name, opts)
+    return (name.to_s.split('.').last || '').titleize unless datatable.active_record_collection?
+
+    case opts[:as]
+    when :belongs_to
+      opts[:resource].human_name
+    when :has_many
+      opts[:resource].human_plural_name
+    else
+      datatable.collection_class.human_attribute_name(name)
     end
+
   end
 
   def datatable_search_tag(datatable, name, opts)
@@ -78,13 +84,13 @@ module EffectiveDatatablesPrivateHelper
     return if opts[:search] == false
 
     # Build the search
-    @_effective_datatables_form_builder || effective_form_with(scope: :datatable_search, url: '#') { |f| @_effective_datatables_form_builder = f }
+    @_effective_datatables_form_builder || effective_form_with(scope: 'datatable_search', url: '#') { |f| @_effective_datatables_form_builder = f }
     form = @_effective_datatables_form_builder
 
     collection = opts[:search].delete(:collection)
     value = datatable.state[:search][name]
 
-    options = opts[:search].except(:fuzzy).merge!(
+    options = opts[:search].merge(
       name: nil,
       feedback: false,
       label: false,
@@ -92,6 +98,8 @@ module EffectiveDatatablesPrivateHelper
       data: { 'column-name': name, 'column-index': opts[:index] }
     )
 
+    options.delete(:fuzzy)
+
     case options.delete(:as)
     when :string, :text, :number
       form.text_field name, options
@@ -139,7 +147,7 @@ module EffectiveDatatablesPrivateHelper
       placeholder: (opts[:label] || name.to_s.titleize),
       value: value,
       wrapper: { class: 'form-group col-auto'}
-    }.merge(opts.except(:as, :collection, :parse))
+    }.merge(opts.except(:as, :collection, :parse, :value))
 
     options[:name] = '' unless datatable._filters_form_required?
 
@@ -149,6 +157,8 @@ module EffectiveDatatablesPrivateHelper
     elsif as == :boolean
       collection ||= [true, false].map { |value| [t("effective_datatables.boolean_#{value}"), value] }
       form.public_send(:select, name, collection, options) # boolean
+    elsif as == :string
+      form.public_send(:text_field, name, options)
     elsif form.respond_to?(as)
       form.public_send(as, name, options) # check_box, text_area
     else
@@ -169,7 +179,7 @@ module EffectiveDatatablesPrivateHelper
       label: false,
       required: false,
       wrapper: { class: 'form-group col-auto'}
-    }.merge(opts)
+    }.merge(opts.except(:checked, :value))
 
     form.radios :scope, collection, options
   end

data/app/models/effective/datatable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Effective
   class Datatable
     attr_reader :attributes # Anything that we initialize our table with. That's it. Can't be changed by state.
-    attr_reader :effective_resource
     attr_reader :state
+    attr_accessor :effective_resource
 
     # Hashes of DSL options
     attr_reader :_aggregates
@@ -21,22 +23,26 @@ module Effective
     # The view
     attr_reader :view
 
+    # Set by DSL so we can track where this datatable is coming from
+    attr_accessor :source_location
+
     extend Effective::EffectiveDatatable::Dsl
 
     include Effective::EffectiveDatatable::Attributes
     include Effective::EffectiveDatatable::Collection
     include Effective::EffectiveDatatable::Compute
     include Effective::EffectiveDatatable::Cookie
+    include Effective::EffectiveDatatable::Csv
     include Effective::EffectiveDatatable::Format
     include Effective::EffectiveDatatable::Hooks
     include Effective::EffectiveDatatable::Params
     include Effective::EffectiveDatatable::Resource
     include Effective::EffectiveDatatable::State
 
-    def initialize(view = nil, attributes = nil) 
+    def initialize(view = nil, attributes = nil)
       (attributes = view; view = nil) if view.kind_of?(Hash)
 
-      @attributes = (attributes || {})
+      @attributes = initial_attributes(attributes)
       @state = initial_state
 
       @_aggregates = {}
@@ -49,13 +55,40 @@ module Effective
 
       raise 'expected a hash of arguments' unless @attributes.kind_of?(Hash)
       raise 'collection is defined as a method. Please use the collection do ... end syntax.' unless collection.nil?
+
       self.view = view if view
     end
 
+    def rendered(params = {})
+      raise('expected a hash of params') unless params.kind_of?(Hash)
+
+      view = ApplicationController.renderer.controller.helpers
+
+      view.class_eval do
+        attr_accessor :rendered_params
+
+        def current_user
+          rendered_params[:current_user]
+        end
+      end
+
+      if params[:current_user_id]
+        params[:current_user] = User.find(params[:current_user_id])
+      end
+
+      view.rendered_params = params
+
+      self.view = view
+      self
+    end
+
     # Once the view is assigned, we initialize everything
     def view=(view)
       @view = (view.respond_to?(:view_context) ? view.view_context : view)
-      raise 'expected view to respond to params' unless @view.respond_to?(:params)
+
+      unless @view.respond_to?(:params) || @view.respond_to?(:rendered_params)
+        raise 'expected view to respond to params'
+      end
 
       assert_attributes!
       load_attributes!
@@ -110,6 +143,10 @@ module Effective
       to_json[:recordsTotal] == 0
     end
 
+    def to_csv
+      csv_file()
+    end
+
     def to_json
       @json ||= (
         {
@@ -137,6 +174,18 @@ module Effective
       !reorder? && attributes[:sortable] != false
     end
 
+    def searchable?
+      attributes[:searchable] != false
+    end
+
+    def downloadable?
+      attributes[:downloadable] != false
+    end
+
+    def skip_save_state?
+      attributes[:skip_save_state] == true
+    end
+
     # Whether the filters must be rendered as a <form> or we can keep the normal <div> behaviour
     def _filters_form_required?
       _form[:verb].present?
@@ -170,6 +219,10 @@ module Effective
       @fallback_effective_resource ||= Effective::Resource.new('', namespace: controller_namespace)
     end
 
+    def default_visibility
+      columns.values.inject({}) { |h, col| h[col[:index]] = col[:visible]; h }
+    end
+
     private
 
     def column_tool

data/app/models/effective/datatable_column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # In practice this is just a regular hash with the aggregate, format, search, sort do syntax that saves a block
 module Effective
   class DatatableColumn

data/app/models/effective/datatable_column_tool.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   class DatatableColumnTool
     attr_reader :datatable
@@ -43,7 +45,7 @@ module Effective
       Rails.logger.info "COLUMN TOOL: order_column #{column.to_s} #{direction} #{sql_column}" if EffectiveDatatables.debug
 
       if column[:sql_as_column]
-        collection.order("#{sql_column} #{datatable.effective_resource.sql_direction(direction)}")
+        collection.order(Arel.sql("#{sql_column} #{datatable.effective_resource.sql_direction(direction)}"))
       else
         Effective::Resource.new(collection)
           .order(column[:name], direction, as: column[:as], sort: column[:sort], sql_column: column[:sql_column], limit: datatable.limit)
@@ -73,10 +75,10 @@ module Effective
     end
 
     def search_column(collection, value, column, sql_column)
-      Rails.logger.info "COLUMN TOOL: search_column #{column.to_s} #{value} #{sql_column}" if EffectiveDatatables.debug
+      Rails.logger.info "COLUMN TOOL: search_column #{column.to_s} value=#{value} operation=#{column[:search][:operation]} column=#{sql_column}" if EffectiveDatatables.debug
 
       Effective::Resource.new(collection)
-        .search(column[:name], value, as: column[:as], fuzzy: column[:search][:fuzzy], sql_column: sql_column)
+        .search(column[:name], value, as: column[:as], operation: column[:search][:operation], column: sql_column)
     end
 
     def paginate(collection)