effective_datatables 3.7.7 → 4.0.0

data/app/helpers/effective_datatables_helper.rb

@@ -1,15 +1,8 @@
 # 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)
-    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
+  def render_datatable(datatable, input_js: {}, buttons: true, charts: true, filters: true, simple: false)
+    raise 'expected datatable to be present' unless datatable
 
     datatable.view ||= self
 
@@ -20,48 +13,29 @@ module EffectiveDatatablesHelper
     charts = charts && datatable._charts.present?
     filters = filters && (datatable._scopes.present? || datatable._filters.present?)
 
-    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
+    datatable.attributes[:simple] = true if simple
+    input_js[:buttons] = false if simple || !buttons
 
     effective_datatable_params = {
       id: datatable.to_param,
-      class: html_class,
+      class: ('effective-datatable ' + Array(datatable.table_html_class).join(' ')),
       data: {
-        'attributes' => EffectiveDatatables.encrypt(datatable.attributes),
-        'authenticity-token' => form_authenticity_token,
         'bulk-actions' => datatable_bulk_actions(datatable),
         'columns' => datatable_columns(datatable),
+        'cookie' => datatable.cookie_key,
         'display-length' => datatable.display_length,
-        'display-order' => datatable_display_order(datatable),
+        'display-order' => [datatable.order_index, datatable.order_direction].to_json().html_safe,
         'display-records' => datatable.to_json[:recordsFiltered],
         'display-start' => datatable.display_start,
-        '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
+        'options' => (input_js || {}).to_json.html_safe,
+        'reset' => datatable_reset(datatable),
+        'simple' => datatable.simple?.to_s,
         'source' => effective_datatables.datatable_path(datatable, {format: 'json'}),
         'total-records' => datatable.to_json[:recordsTotal]
       }
     }
 
-    if (charts || filters)
+    if (charts || filters) && !simple
       output = ''.html_safe
 
       if charts
@@ -84,28 +58,59 @@ module EffectiveDatatablesHelper
     end
   end
 
-  def render_inline_datatable(datatable)
-    render_datatable(datatable, inline: true)
+  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: ('effective-datatable simple ' + Array(datatable.table_html_class).join(' ')),
+      data: {}
+    }
+
+    render(partial: 'effective/datatables/datatable',
+      locals: { datatable: datatable, effective_datatable_params: effective_datatable_params }
+    )
   end
 
-  def render_simple_datatable(datatable)
-    render_datatable(datatable, simple: true)
+  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 inline_datatable?
-    params[:_datatable_id].present? && params[:_datatable_attributes].present?
+  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 inline_datatable
-    return nil unless inline_datatable?
-    return @_inline_datatable if @_inline_datatable
+  def render_datatable_chart(datatable, name)
+    raise 'expected datatable to be present' unless datatable
 
-    datatable = EffectiveDatatables.find(params[:_datatable_id], params[:_datatable_attributes])
-    datatable.view = self
+    datatable.view ||= self
+    return unless datatable._charts[name].present?
 
-    EffectiveDatatables.authorize!(self, :index, datatable.collection_class)
+    chart = datatable._charts[name]
+    chart_data = datatable.to_json[:charts][name][:data]
 
-    @_inline_datatable ||= datatable
+    render partial: chart[:partial], locals: { datatable: datatable, chart: chart, chart_data: chart_data }
   end
 
 end

data/app/helpers/effective_datatables_private_helper.rb

@@ -1,21 +1,18 @@
 # 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)
-    sortable = datatable.sortable?
-
     datatable.columns.map do |name, opts|
       {
-        className: opts[:col_class],
         name: name,
+        title: content_tag(:span, opts[:label].presence),
+        className: opts[:col_class],
         responsivePriority: opts[:responsive],
         search: datatable.state[:search][name],
         searchHtml: datatable_search_tag(datatable, name, opts),
-        sortable: (opts[:sort] && sortable),
-        title: datatable_label_tag(datatable, name, opts),
-        visible: datatable.state[:visible][name]
+        sortable: (opts[:sort] && !datatable.simple?),
+        visible: datatable.state[:visible][name],
       }
     end.to_json.html_safe
   end
@@ -26,207 +23,78 @@ 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)
-    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_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.try(:klass) || datatable.collection_class)
-    elsif Array(datatable.effective_resource.try(: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
+    link_to(content_tag(:span, 'Reset'), '#', class: 'btn btn-link btn-sm buttons-reset-search')
   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 }
+    @_effective_datatables_form_builder || effective_form_with(scope: :datatable_search, url: '#') { |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 = {
+    options = opts[:search].except(:fuzzy).merge!(
       name: nil,
+      feedback: false,
+      label: false,
       value: value,
-      title: title,
-      pattern: pattern,
-      data: {'column-name' => name, 'column-index' => opts[:index]}
-    }.delete_if { |k, v| v.blank? && k != :name }
+      data: { 'column-name': name, 'column-index': opts[:index] }
+    )
 
-    case opts[:search][:as]
+    case options.delete(:as)
     when :string, :text, :number
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_html: input_html
-    when :effective_obfuscation
-      input_html[:pattern] ||= '[0-9]{3}-?[0-9]{4}-?[0-9]{3}'
-      input_html[:title] = 'Expected format: XXX-XXXX-XXX'
-
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_html: input_html
+      form.text_field name, options
     when :date, :datetime
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_date_picker) ? :effective_date_picker : :string),
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_group: false,
-        input_html: input_html,
-        date_linked: false,
-        input_js: { useStrict: true, keepInvalid: true }
-        # Keep invalid format like "2015-11" so we can still search by year, month or day
+      form.date_field name, options.reverse_merge(
+        date_linked: false, prepend: false, input_js: { useStrict: true, keepInvalid: true }
+      )
     when :time
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_time_picker) ? :effective_time_picker : :string),
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_group: false,
-        input_html: input_html,
-        date_linked: false,
-        input_js: { useStrict: false, keepInvalid: true }
+      form.time_field name, options.reverse_merge(
+        date_linked: false, prepend: false, input_js: { useStrict: false, keepInvalid: true }
+      )
     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: collection,
-        selected: opts[:search][:value],
-        multiple: opts[:search][:multiple],
-        grouped: opts[:search][:grouped],
-        polymorphic: opts[:search][:polymorphic],
-        template: opts[:search][:template],
-        include_blank: include_blank,
-        wrapper_html: wrapper_html,
-        input_html: input_html,
-        input_js: { placeholder: placeholder }
+      options[:input_js] = (options[:input_js] || {}).reverse_merge(placeholder: '')
+      form.select name, collection, options
     when :bulk_actions
-      input_html[:data]['role'] = 'bulk-actions'
-
-      form.input name, label: false, required: false, value: nil,
-        as: :boolean,
-        input_html: input_html
-    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
+      options[:data]['role'] = 'bulk-actions-all'
+      form.check_box name, options.merge(custom: false)
     end
-
   end
 
   def datatable_filter_tag(form, datatable, name, opts)
-    as = opts[:as].to_s.chomp('_field').to_sym
+    placeholder = opts.delete(:label)
+
+    collection = opts.delete(:collection)
     value = datatable.state[:filter][name]
-    collection = opts[:collection]
-    input_html = opts[:input_html] || {}
 
-    attributes = {
+    options = opts.except(:parse).merge(
+      placeholder: placeholder,
+      feedback: false,
+      label: false,
       value: value,
-      selected: value,
-      as: as,
-      collection: collection,
-      label: opts[:label],
-      required: input_html.delete(:required) || opts[:required],
-      multiple: input_html.delete(:multiple) || opts[:multiple],
-      include_blank: input_html.delete(:include_blank) || opts[: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'}
-    }.compact
-
-    form.input name, **attributes
-  end
-
-  def datatable_scope_tag(form, datatable, opts = {})
-    collection = datatable._scopes.map { |name, opts| [opts[:label], name] }
-    value = datatable.state[:scope]
+      wrapper: { class: 'form-group col-auto'},
+      autocomplete: 'off'
+    )
 
-    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
+    options[:name] = '' unless datatable._filters_form_required?
 
-    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 }
+    case options.delete(:as)
+    when :date
+      form.date_field name, options
+    when :datetime
+      form.datetime_field name, options
+    when :time
+      form.time_field name, options
+    when :select, :boolean
+      options[:input_js] = (options[:input_js] || {}).reverse_merge(placeholder: placeholder)
+      form.select name, collection, options
+    else
+      form.text_field name, options
+    end
   end
 
 end

data/app/models/effective/datatable.rb

@@ -1,7 +1,7 @@
 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 :resource
     attr_reader :state
 
     # Hashes of DSL options
@@ -15,8 +15,6 @@ module Effective
 
     # The collection itself. Only evaluated once.
     attr_accessor :_collection
-    attr_accessor :_collection_apply_belongs_to
-    attr_accessor :_collection_apply_scope
 
     # The view
     attr_reader :view
@@ -33,10 +31,10 @@ module Effective
     include Effective::EffectiveDatatable::Resource
     include Effective::EffectiveDatatable::State
 
-    def initialize(view = nil, attributes = nil)
+    def initialize(view = nil, attributes = {})
       (attributes = view; view = nil) if view.kind_of?(Hash)
 
-      @attributes = (attributes || {})
+      @attributes = initial_attributes(attributes)
       @state = initial_state
 
       @_aggregates = {}
@@ -47,7 +45,6 @@ module Effective
       @_form = {}
       @_scopes = {}
 
-      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
@@ -57,23 +54,21 @@ module Effective
       @view = (view.respond_to?(:view_context) ? view.view_context : view)
       raise 'expected view to respond to params' unless @view.respond_to?(:params)
 
-      assert_attributes!
+      load_cookie!
       load_attributes!
 
       # We need early access to filter and scope, to define defaults from the model first
-      # This means filters do know about attributes but not about columns.
+      # This means filters do knows about attributes but not about columns.
       initialize_filters if respond_to?(:initialize_filters)
       load_filters!
       load_state!
 
-      # Bulk actions called first so it can add the bulk_actions_col first
-      initialize_bulk_actions if respond_to?(:initialize_bulk_actions)
-
       # Now we initialize all the columns. columns knows about attributes and filters and scope
       initialize_datatable if respond_to?(:initialize_datatable)
       load_columns!
 
       # Execute any additional DSL methods
+      initialize_bulk_actions if respond_to?(:initialize_bulk_actions)
       initialize_charts if respond_to?(:initialize_charts)
 
       # Load the collection. This is the first time def collection is called on the Datatable itself
@@ -83,10 +78,9 @@ module Effective
       # Figure out the class, and if it's activerecord, do all the resource discovery on it
       load_resource!
 
-      # Check everything is okay
-      validate_datatable!
+      # If attributes match a belongs_to column, scope the collection and remove the column
+      apply_belongs_to_attributes!
 
-      # Save for next time
       save_cookie!
     end
 
@@ -123,18 +117,11 @@ module Effective
       )
     end
 
-    # Inline crud
-    def inline?
-      attributes[:inline] == true
-    end
-
-    # Reordering
-    def reorder?
-      columns.key?(:_reorder)
-    end
-
-    def sortable?
-      !reorder? && attributes[:sortable] != false
+    # When simple only a table will be rendered with
+    # no sorting, no filtering, no export buttons, no pagination, no per page, no colReorder
+    # default sorting only, default visibility only, all records returned, and responsive enabled
+    def simple?
+      attributes[:simple] == true
     end
 
     # Whether the filters must be rendered as a <form> or we can keep the normal <div> behaviour
@@ -142,12 +129,12 @@ module Effective
       _form[:verb].present?
     end
 
-    def html_class
-      Array(attributes[:class] || EffectiveDatatables.html_class).join(' ').presence
+    def table_html_class
+      attributes[:class] || EffectiveDatatables.html_class
     end
 
     def to_param
-      "#{self.class.name.underscore.parameterize}-#{[self.class, attributes].hash.abs.to_s.last(12)}"
+      @to_param ||= "#{self.class.name.underscore.parameterize}-#{cookie_param}"
     end
 
     def columns
@@ -162,14 +149,6 @@ module Effective
       @dsl_tool ||= DatatableDslTool.new(self)
     end
 
-    def resource
-      raise('depecated. Please use .effective_resource instead')
-    end
-
-    def fallback_effective_resource
-      @fallback_effective_resource ||= Effective::Resource.new('', namespace: controller_namespace)
-    end
-
     private
 
     def column_tool
@@ -180,12 +159,5 @@ module Effective
       @value_tool ||= DatatableValueTool.new(self)
     end
 
-    def validate_datatable!
-      if reorder?
-        raise 'cannot use reorder with an Array collection' unless active_record_collection?
-        raise 'cannot use reorder with a non-Integer column' if effective_resource.sql_type(columns[:_reorder][:reorder]) != :integer
-      end
-    end
-
   end
 end