effective_datatables 3.6.3 → 3.7.0

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

@@ -0,0 +1,7 @@
+$.extend(true, $.fn.dataTable.Buttons.defaults, {
+  dom: {
+    button: {
+      className: 'btn btn-link btn-sm'
+    }
+  }
+});

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

@@ -0,0 +1,43 @@
+reorder = (event, diff, edit) ->
+  change = diff.find (obj) -> obj.node == edit.triggerRow.node()
+  return unless change?
+
+  $table = $(event.currentTarget)
+  oldNode = $("<div>#{change.oldData}</div>").find('input[data-reorder-resource]')
+  newNode = $("<div>#{change.newData}</div>").find('input[data-reorder-resource]')
+  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') }
+
+  @context[0].rowreorder.c.enable = false
+
+  $.ajax(
+    method: 'post',
+    url: url,
+    data: data,
+    async: false
+  ).fail((response, text, status) =>
+    $(event.target).closest('table').DataTable().flash(status, 'danger')
+  ).always((response) =>
+    @context[0].rowreorder.c.enable = true
+  )
+
+$.fn.DataTable.Api.register('reorder()', reorder);
+
+$(document).on 'click', '.dataTables_wrapper a.buttons-reorder', (event) ->
+  event.preventDefault() # prevent the click
+
+  $link = $(event.currentTarget)
+  $table = $link.closest('.dataTables_wrapper').find('table.dataTable').first()
+
+  column = $table.DataTable().column('.col-_reorder')
+  return unless column.length > 0
+
+  if column.visible()
+    $table.removeClass('reordering')
+  else
+    $table.addClass('reordering')
+
+  column.visible(!column.visible())
+

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

@@ -1,4 +1,4 @@
-$(document).on 'click', 'a.buttons-reset-search', (event) ->
+$(document).on 'click', '.dataTables_wrapper a.buttons-reset-search', (event) ->
   event.preventDefault() # prevent the click
 
   $table = $(event.currentTarget).closest('.dataTables_wrapper').find('table.dataTable').first()

data/app/assets/stylesheets/effective_datatables/_overrides.scss

@@ -35,6 +35,8 @@ table.dataTable thead {
     border-bottom: none;
     white-space: nowrap;
     padding: 6px;
+
+    span { display: block; }
   }
 
   .form-control, .form-group {
@@ -194,3 +196,29 @@ table.dataTable {
     p { margin-bottom: 0px; }
   }
 }
+
+// Simple styles
+table.dataTable.hide-sort > thead {
+  .sorting { background-image: none; cursor: default; }
+  .sorting_asc { background-image: none; cursor: default; }
+  .sorting_desc { background-image: none; cursor: default; }
+}
+
+table.dataTable.hide-search > thead {
+  .form-group { display: none; }
+}
+
+table.dataTable.hide-buttons {
+  .col-bulk_actions { display: none; }
+}
+
+// Datatables entries
+@media screen and (max-width: 767px) {
+  div.dataTables_wrapper div.dataTables_entries { text-align: center; }
+}
+
+.dataTables_buttons {
+  .buttons-bulk-actions {
+    button { font-size: 12px; }
+  }
+}

data/app/controllers/effective/datatables_controller.rb

@@ -5,7 +5,7 @@ module Effective
     # This will respond to both a GET and a POST
     def show
       begin
-        @datatable = find_datatable(params[:id]).try(:new) || raise('unable to find datatable')
+        @datatable = EffectiveDatatables.find(params[:id], params[:attributes])
         @datatable.view = view_context
 
         EffectiveDatatables.authorize!(self, :index, @datatable.collection_class)
@@ -13,18 +13,51 @@ module Effective
         render json: @datatable.to_json
       rescue => e
         EffectiveDatatables.authorized?(self, :index, @datatable.try(:collection_class))
-
         render json: error_json(e)
+
+        ExceptionNotifier.notify_exception(e) if defined?(ExceptionNotifier)
+        raise e if Rails.env.development?
       end
     end
 
-    private
+    def reorder
+      begin
+        @datatable = EffectiveDatatables.find(params[:id], params[:attributes])
+        @datatable.view = view_context
+
+        EffectiveDatatables.authorize!(self, :index, @datatable.collection_class)
+
+        @resource = @datatable.collection.find(params[:reorder][:id])
+
+        EffectiveDatatables.authorize!(self, :update, @resource)
+
+        attribute = @datatable.columns[:_reorder][:reorder]
+        old_index = params[:reorder][:old].to_i
+        new_index = params[:reorder][:new].to_i
+
+        @resource.class.transaction do
+          if new_index > old_index
+            @datatable.collection.where("#{attribute} > ? AND #{attribute} <= ?", old_index, new_index).update_all("#{attribute} = #{attribute} - 1")
+            @resource.update_column(attribute, new_index)
+          end
+
+          if old_index > new_index
+            @datatable.collection.where("#{attribute} >= ? AND #{attribute} < ?", new_index, old_index).update_all("#{attribute} = #{attribute} + 1")
+            @resource.update_column(attribute, new_index)
+          end
+        end
+
+        render status: :ok, body: :ok
+      rescue Effective::AccessDenied => e
+        render(status: :unauthorized, body: 'Access Denied')
+      rescue => e
+        render(status: :error, body: 'Unexpected Error')
+      end
 
-    def find_datatable(id)
-      id = id.to_s.gsub(/-\d+\z/, '').gsub('-', '/')
-      id.classify.safe_constantize || id.classify.pluralize.safe_constantize
     end
 
+    private
+
     def error_json(e)
       {
         data: [],

data/app/datatables/effective_style_guide_datatable.rb

@@ -0,0 +1,47 @@
+class EffectiveStyleGuideDatatable < Effective::Datatable
+  datatable do
+    length 10
+
+    col :id
+    col :material, search: { collection: ['Stainless Steel', 'Copper', 'Cast Iron', 'Composite'] }
+    col :bowl, search: { collection: ['Single Bowl', 'Double Bowl', 'Triple Bowl'] }
+    col :name
+    col :date, as: :date
+
+    actions_col
+  end
+
+  # Set the permission check to the same as Effective::StyleGuide
+  def collection_class
+    defined?(Effective::StyleGuide) ? Effective::StyleGuide : super
+  end
+
+  collection do
+    now = Time.zone.now
+    [
+      [1, 'Stainless Steel', 'Single Bowl', 'KOHLER Staccato', (now + 1.day)],
+      [2, 'Stainless Steel', 'Double Bowl', 'KOHLER Vault Undercounter', (now + 1.day)],
+      [3, 'Stainless Steel', 'Triple Bowl', 'KRAUS All-In-One', (now + 1.day)],
+      [4, 'Stainless Steel', 'Single Bowl', 'KOHLER Vault Dual Mount', (now + 1.day)],
+      [5, 'Stainless Steel', 'Single Bowl', 'KRAUS All-In-One Undermount', (now + 2.days)],
+      [6, 'Stainless Steel', 'Double Bowl', 'Glacier Bay All-in-One', (now + 2.days)],
+      [7, 'Stainless Steel', 'Single Bowl', 'Elkay Neptune', (now + 2.days)],
+      [8, 'Copper', 'Single Bowl', 'ECOSINKS Apron Front Dual Mount', (now + 2.days)],
+      [9, 'Copper', 'Double Bowl', 'ECOSINKS Dual Mount Front Hammered', (now + 2.days)],
+      [10, 'Copper', 'Triple Bowl', 'Glarier Bay Undermount', (now + 3.days)],
+      [11, 'Copper', 'Single Bowl', 'Whitehaus Undermount', (now + 3.days)],
+      [12, 'Copper', 'Double Bowl', 'Belle Foret Apron Front', (now + 3.days)],
+      [13, 'Copper', 'Double Bowl', 'Pegasus Dual Mount', (now + 3.days)],
+      [14, 'Cast Iron', 'Double Bowl', 'KOHLER Whitehaven', (now + 3.days)],
+      [15, 'Cast Iron', 'Triple Bowl', 'KOHLER Hartland', (now + 3.days)],
+      [16, 'Cast Iron', 'Single Bowl', 'KOHLER Cape Dory Undercounter', (now + 4.days)],
+      [17, 'Cast Iron', 'Double Bowl', 'KOLER Bakersfield', (now + 4.days)],
+      [18, 'Cast Iron', 'Double Bowl', 'American Standard Offset', (now + 4.days)],
+      [19, 'Cast Iron', 'Single Bowl', 'Brookfield Top', (now + 4.days)],
+      [20, 'Composite', 'Single Bowl', 'Blanco Diamond Undermount', (now + 5.days)],
+      [21, 'Composite', 'Double Bowl', 'Mont Blanc Waterbrook', (now + 5.days)],
+      [22, 'Composite', 'Triple Bowl', 'Pegasus Triple Mount', (now + 5.days)],
+      [23, 'Composite', 'Single Bowl', 'Swanstone Dual Mount', (now + 5.days)]
+    ]
+  end
+end

data/app/helpers/effective_datatables_helper.rb

@@ -1,8 +1,15 @@
 # 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, filters: true, simple: false)
+  def render_datatable(datatable, input_js: {}, buttons: true, charts: true, entries: true, filters: true, inline: false, 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 simple
+      buttons = charts = entries = filters = pagination = search = sort = false
+    end
+
+    datatable.attributes[:inline] = true if inline
+    datatable.attributes[:sortable] = false unless sort
 
     datatable.view ||= self
 
@@ -13,31 +20,48 @@ module EffectiveDatatablesHelper
     charts = charts && datatable._charts.present?
     filters = filters && (datatable._scopes.present? || datatable._filters.present?)
 
-    datatable.attributes[:simple] = true if simple
-    input_js[:buttons] = false if simple || !buttons
+    html_class = ['effective-datatable', datatable.html_class, ('hide-sort' unless sort), ('hide-search' unless search), ('hide-buttons' unless buttons)].compact.join(' ')
+
+    if datatable.reorder? && !buttons
+      buttons = true; input_js[:buttons] = false
+    end
+
+    # Build the datatables DOM option
+    input_js[:dom] ||= [
+      ("<'row'<'col-sm-12 dataTables_buttons'B>>" if buttons),
+      "<'row'<'col-sm-12'tr>>",
+      ("<'row'" if entries || pagination),
+      ("<'col-sm-6 dataTables_entries'il>" if entries),
+      ("<'col-sm-6'p>" if pagination),
+      (">" if entries || pagination)
+    ].compact.join
 
     effective_datatable_params = {
       id: datatable.to_param,
-      class: ('effective-datatable ' + Array(datatable.table_html_class).join(' ')),
+      class: html_class,
       data: {
+        'attributes' => EffectiveDatatables.encrypt(datatable.attributes),
         'authenticity-token' => form_authenticity_token,
-        'effective-form-inputs' => defined?(EffectiveFormInputs),
         'bulk-actions' => datatable_bulk_actions(datatable),
         'columns' => datatable_columns(datatable),
-        'cookie' => datatable.cookie_key,
         'display-length' => datatable.display_length,
-        'display-order' => [datatable.order_index, datatable.order_direction].to_json().html_safe,
+        'display-order' => datatable_display_order(datatable),
         'display-records' => datatable.to_json[:recordsFiltered],
         'display-start' => datatable.display_start,
-        'input-js-options' => (input_js || {}).to_json.html_safe,
-        'reset' => datatable_reset(datatable),
-        'simple' => datatable.simple?.to_s,
+        '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-index' => (datatable.columns[:_reorder][:index] if datatable.reorder?).to_s,
+        'simple' => simple.to_s,
+        'spinner' => '', # effective_bootstrap
         'source' => effective_datatables.datatable_path(datatable, {format: 'json'}),
         'total-records' => datatable.to_json[:recordsTotal]
       }
     }
 
-    if (charts || filters) && !simple
+    if (charts || filters)
       output = ''.html_safe
 
       if charts
@@ -60,59 +84,28 @@ module EffectiveDatatablesHelper
     end
   end
 
-  def render_simple_datatable(datatable)
-    raise 'expected datatable to be present' unless datatable
-
-    datatable.view ||= self
-
-    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
-
-    effective_datatable_params = {
-      id: datatable.to_param,
-      class: Array(datatable.table_html_class).join(' '),
-      data: {}
-    }
-
-    render(partial: 'effective/datatables/datatable',
-      locals: { datatable: datatable, effective_datatable_params: effective_datatable_params }
-    )
+  def render_inline_datatable(datatable)
+    render_datatable(datatable, inline: true)
   end
 
-  def render_datatable_filters(datatable)
-    raise 'expected datatable to be present' unless datatable
-
-    datatable.view ||= self
-    return unless datatable._scopes.present? || datatable._filters.present?
-
-    if datatable._filters_form_required?
-      render partial: 'effective/datatables/filters', locals: { datatable: datatable }
-    else
-      render(partial: 'effective/datatables/filters', locals: { datatable: datatable }).gsub('<form', '<div').gsub('/form>', '/div>').html_safe
-    end
-
+  def render_simple_datatable(datatable)
+    render_datatable(datatable, simple: true)
   end
 
-  def render_datatable_charts(datatable)
-    raise 'expected datatable to be present' unless datatable
-
-    datatable.view ||= self
-    return unless datatable._charts.present?
-
-    datatable._charts.map { |name, _| render_datatable_chart(datatable, name) }.join.html_safe
+  def inline_datatable?
+    params[:_datatable_id].present? && params[:_datatable_attributes].present?
   end
 
-  def render_datatable_chart(datatable, name)
-    raise 'expected datatable to be present' unless datatable
+  def inline_datatable
+    return nil unless inline_datatable?
+    return @_inline_datatable if @_inline_datatable
 
-    datatable.view ||= self
-    return unless datatable._charts[name].present?
+    datatable = EffectiveDatatables.find(params[:_datatable_id], params[:_datatable_attributes])
+    datatable.view = self
 
-    chart = datatable._charts[name]
-    chart_data = datatable.to_json[:charts][name][:data]
+    EffectiveDatatables.authorize!(self, :index, datatable.collection_class)
 
-    render partial: chart[:partial], locals: { datatable: datatable, chart: chart, chart_data: chart_data }
+    @_inline_datatable ||= datatable
   end
 
 end

data/app/helpers/effective_datatables_private_helper.rb

@@ -1,21 +1,21 @@
 # These aren't expected to be called by a developer. They are internal methods.
+# These aren't expected to be called by a developer. They are internal methods.
 module EffectiveDatatablesPrivateHelper
 
   # https://datatables.net/reference/option/columns
   def datatable_columns(datatable)
-    form = nil
-    simple_form_for(:datatable_search, url: '#', html: {id: "#{datatable.to_param}-form"}) { |f| form = f }
+    sortable = datatable.sortable?
 
     datatable.columns.map do |name, opts|
       {
-        name: name,
-        title: content_tag(:span, (opts[:label] == false ? '' : opts[:label]), class: 'search-label'),
         className: opts[:col_class],
-        searchHtml: (datatable_search_html(form, name, datatable.state[:search][name], opts) unless datatable.simple?),
+        name: name,
         responsivePriority: opts[:responsive],
         search: datatable.state[:search][name],
-        sortable: (opts[:sort] && !datatable.simple?),
-        visible: datatable.state[:visible][name],
+        searchHtml: datatable_search_tag(datatable, name, opts),
+        sortable: (opts[:sort] && sortable),
+        title: datatable_label_tag(datatable, name, opts),
+        visible: datatable.state[:visible][name]
       }
     end.to_json.html_safe
   end
@@ -26,17 +26,71 @@ module EffectiveDatatablesPrivateHelper
     end
   end
 
+  def datatable_display_order(datatable)
+    (datatable.sortable? ? [datatable.order_index, datatable.order_direction] : false).to_json.html_safe
+  end
+
   def datatable_reset(datatable)
-    render(partial: '/effective/datatables/reset', locals: { datatable: datatable }).gsub("'", '"').html_safe
+    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)
   end
 
-  def datatable_search_html(form, name, value, opts)
+  def datatable_new_resource_button(datatable, name, column)
+    return unless column[: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])
+
+      effective_resource = (datatable.effective_resource || datatable.fallback_effective_resource)
+      klass = (column[:actions][:new][:klass] || effective_resource&.klass || datatable.collection_class)
+    elsif Array(datatable.effective_resource&.actions).include?(:new)
+      effective_resource = datatable.effective_resource
+      klass = effective_resource.klass
+    else
+      return
+    end
+
+    # Will only work if permitted
+    render_resource_actions(klass, actions: { t('effective_datatables.new') => action }, effective_resource: effective_resource)
+  end
+
+  def datatable_label_tag(datatable, name, opts)
+    case opts[:as]
+    when :actions
+      content_tag(:span, t('effective_datatables.actions'), style: 'display: none;')
+    when :bulk_actions
+      content_tag(:span, t('effective_datatables.bulk_actions'), style: 'display: none;')
+    when :reorder
+      content_tag(:span, t('effective_datatables.reorder'), style: 'display: none;')
+    else
+      content_tag(:span, opts[:label].presence)
+    end
+  end
+
+  def datatable_search_tag(datatable, name, opts)
+    return datatable_new_resource_button(datatable, name, opts) if name == :_actions
+
+    return if opts[:search] == false
+
+    # Build the search
+    @_effective_datatables_form_builder ||  simple_form_for(:datatable_search, url: '#', html: {id: "#{datatable.to_param}-form"}) { |f| @_effective_datatables_form_builder = f }
+    form = @_effective_datatables_form_builder
+
     include_blank = opts[:search].key?(:include_blank) ? opts[:search][:include_blank] : opts[:label]
     pattern = opts[:search][:pattern]
     placeholder = opts[:search][:placeholder] || ''
     title = opts[:search][:title] || opts[:label]
     wrapper_html = { class: 'datatable_search' }
 
+    collection = opts[:search].delete(:collection)
+    value = datatable.state[:search][name]
+
     input_html = {
       name: nil,
       value: value,
@@ -83,7 +137,7 @@ module EffectiveDatatablesPrivateHelper
     when :select, :boolean
       form.input name, label: false, required: false, value: value,
         as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_select) ? :effective_select : :select),
-        collection: opts[:search][:collection],
+        collection: collection,
         selected: opts[:search][:value],
         multiple: opts[:search][:multiple],
         grouped: opts[:search][:grouped],
@@ -102,4 +156,76 @@ module EffectiveDatatablesPrivateHelper
     end
   end
 
-end
+  def render_datatable_filters(datatable)
+    raise 'expected datatable to be present' unless datatable
+
+    datatable.view ||= self
+    return unless datatable._scopes.present? || datatable._filters.present?
+
+    if datatable._filters_form_required?
+      render partial: 'effective/datatables/filters', locals: { datatable: datatable }
+    else
+      render(partial: 'effective/datatables/filters', locals: { datatable: datatable }).gsub('<form', '<div').gsub('/form>', '/div>').html_safe
+    end
+
+  end
+
+  def datatable_filter_tag(form, datatable, name, opts)
+    as = opts[:as].to_s.chomp('_field').to_sym
+    value = datatable.state[:filter][name]
+    collection = opts[:collection]
+    input_html = opts[:input_html] || {}
+
+    binding.pry
+
+    form.input name,
+      value: value,
+      selected: value,
+      as: as,
+      collection: collection,
+      label: opts[:label],
+      required: input_html.delete(:required),
+      multiple: input_html.delete(:multiple),
+      include_blank: input_html.delete(:include_blank),
+      group_method: input_html.delete(:group_method),
+      group_label_method: input_html.delete(:group_label_method),
+      value_method: input_html.delete(:value_method),
+      label_method: input_html.delete(:label_method),
+      input_html: (({name: ''} unless datatable._filters_form_required?) || {}).merge(input_html),
+      input_js: ({ placeholder: ''} if as == :effective_select),
+      wrapper_html: {class: 'form-group-sm'}
+  end
+
+  def datatable_scope_tag(form, datatable, opts = {})
+    collection = datatable._scopes.map { |name, opts| [opts[:label], name] }
+    value = datatable.state[:scope]
+
+    form.input :scope, label: false, required: false, checked: value,
+      as: (defined?(EffectiveFormInputs) ? :effective_radio_buttons : :radio_buttons),
+      collection: collection,
+      buttons: true,
+      wrapper_html: {class: 'btn-group-sm'}
+  end
+
+  def render_datatable_charts(datatable)
+    raise 'expected datatable to be present' unless datatable
+
+    datatable.view ||= self
+    return unless datatable._charts.present?
+
+    datatable._charts.map { |name, _| render_datatable_chart(datatable, name) }.join.html_safe
+  end
+
+  def render_datatable_chart(datatable, name)
+    raise 'expected datatable to be present' unless datatable
+
+    datatable.view ||= self
+    return unless datatable._charts[name].present?
+
+    chart = datatable._charts[name]
+    chart_data = datatable.to_json[:charts][name][:data]
+
+    render partial: chart[:partial], locals: { datatable: datatable, chart: chart, chart_data: chart_data }
+  end
+
+end