effective_datatables 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7bd5fa4ae2a9aa6654ae6341bc6e324741c0387
-  data.tar.gz: b14fdda1521d4046ffc94aaf3fa173ab8d42863c
+  metadata.gz: eb195f3890afb3faee956495d534e0a1bb09013e
+  data.tar.gz: 8acf1b7ec6a347a3157718504f6830a001d0360c
 SHA512:
-  metadata.gz: 83d1fbcad25d8ae5b780efbc70b61c9b8bb2fca94bff5397c640567663efa892a3d0f240f10fc7c15b1781935c7f45df0d45218e4d1abc2cdefc3dbe0dbc38a4
-  data.tar.gz: 96e02057d1cd10ca8c57b8adc8d6b182b3ec291b91cefcc32e1fa6a2bb7382b1fbcd0f04759b2db9c457b1d7f8e9dad8540003bdfbd7e71b02fb9d80d1d245c2
+  metadata.gz: d8cb8fc4dbb8f209bd2a5259e5c0f1594a5c1bb0a8dc763cbd0ae55b63b8194bb5ca96649fd0fbf5b4b97b6bec8cbc06fa8da7144e04d67aeb1c49fce52accfa
+  data.tar.gz: 4d9addc52f7eac6742137e29a967aa465a69bd2c4baadcbebbb248b6dcedf6eab3457819e8002447aaf729a59d1a631232ea646ec484bd4fbabd63ae9acd63e3

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

@@ -20,18 +20,30 @@ initializeDataTables = ->
           { sortable: false, targets: datatable.data('non-sortable') }
         ].concat(datatable.data('column-classes') || []).concat(datatable.data('column-names') || [])
         order: datatable.data('default-order')
+        serverParams: (params) ->
+          table = this.DataTable()
+          table.columns().flatten().each (index) =>  # Pass which columns are visible back to server
+            params['columns'][index]['visible'] =  table.column(index).visible()
         colVis:
           showAll: 'Show all'
           restore: 'Show default'
           activate: 'click'
           align: 'right'
           label: (index, title, th) -> $(th).prop('title')
+          stateChange: (iCol, bVisible) ->
+            timeout = $(this.dom.button).data('timeout')
+            clearTimeout(timeout) if timeout
+            timeout = setTimeout(
+              =>
+                $(this.dom.button).closest('.dataTables_wrapper').find('table').first().DataTable().draw()
+                $.event.trigger('page:change')
+            , 1000)
+            $(this.dom.button).data('timeout', timeout)
         tableTools:
           sSwfPath: "<%= asset_path('effective_datatables/copy_csv_xls_pdf.swf') %>",
           aButtons: ['csv', {'sExtends': 'xls', 'sButtonText': 'Excel'}, 'print']
 
-      simple = datatable.data('effective-datatables-table') == 'simple'
-      if simple
+      if datatable.data('effective-datatables-table') == 'simple'
         init_options['lengthMenu'] = [-1] # Show all results
         init_options['dom'] = "<'row'r>t" # Just show the table
 
@@ -46,12 +58,14 @@ initializeDataTables = ->
         table.DataTable().column("#{obj.data('column-name')}:name").search(obj.val()).draw()
 
       # For every existing Input, Set up the search events
-      (search_inputs = datatable.find('thead').first().find('input,select')).each (index, input) ->
+      search_inputs = datatable.find('thead').first().find('input,select')
+
+      search_inputs.each (index, input) ->
         $input = $(input)
 
         if $input.data('column-name')
-          $input.on 'click', (event) -> false # Dont order columns when you click inside the input
-          $input.on 'mousedown', (event) -> event.stopPropagation() # Dont order columns when you click inside the input
+          $input.parent().on 'click', (event) -> false # Dont order columns when you click inside the input
+          $input.parent().on 'mousedown', (event) -> event.stopPropagation() # Dont order columns when you click inside the input
 
           if $input.is('select')
             $input.on 'change', (event) -> dataTableSearch(event)

data/app/controllers/effective/datatables_controller.rb

@@ -1,6 +1,6 @@
 module Effective
   class DatatablesController < ApplicationController
-    skip_log_page_views if defined?(EffectiveLogging)
+    skip_log_page_views quiet: true if defined?(EffectiveLogging)
 
     # This will respond to both a GET and a POST
     def show

data/app/helpers/effective_datatables_helper.rb

@@ -31,8 +31,13 @@ module EffectiveDatatablesHelper
         end
       end
 
-      form.input name, label: false, required: false, as: :select, collection: opts[:filter][:values], include_blank: (opts[:label] || name.titleize),
-        input_html: { name: nil, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} }
+      form.input name, label: false, required: false,
+        as: (defined?(EffectiveFormInputs) ? :effective_select : :select),
+        collection: opts[:filter][:values],
+        multiple: opts[:filter][:multiple] == true,
+        include_blank: (opts[:label] || name.titleize),
+        input_html: { name: nil, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        input_js: { placeholder: (opts[:label] || name.titleize) }
     else
       content_tag(:p, opts[:label] || name)
     end

data/app/models/effective/active_record_datatable_tool.rb

@@ -46,6 +46,22 @@ module Effective
         else
           collection.where("#{column} ILIKE :term", term: "%#{term}%")
         end
+      when :has_many
+        inverse_ids = term.split(',').map { |term| (term = term.to_i) == 0 ? nil : term }.compact
+        return collection unless inverse_ids.present?
+
+        reflection = collection.klass.reflect_on_association(table_column[:name].to_sym)
+        raise "unable to find #{collection.klass.name} :has_many :#{table_column[:name]} association" unless reflection
+
+        obj = reflection.build_association({}) # Clinic
+        klass = obj.class
+
+        inverse = klass.reflect_on_association(collection.table_name) || obj.class.reflect_on_association(collection.table_name.singularize)
+        raise "unable to find #{klass.name} has_many :#{collection.table_name} or belongs_to :#{collection.table_name.singularize} associations" unless inverse
+
+        ids = klass.where(id: inverse_ids).joins(inverse.name).pluck(inverse.foreign_key)
+
+        collection.where(id: ids)
       when :datetime, :date
         begin
           digits = term.scan(/(\d+)/).flatten.map(&:to_i)

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

@@ -8,12 +8,11 @@ module Effective
       # It sends us a list of columns that are different than our table_columns order
       # So this method just returns an array of column names, as per ColReorder
       def display_table_columns
-        if params[:columns].present?
-          HashWithIndifferentAccess.new().tap do |display_columns|
-            params[:columns].each do |_, values|
-              display_columns[values[:name]] = table_columns[values[:name]]
-            end
-          end
+        return nil if params[:columns].blank?
+
+        @display_table_columns ||= params[:columns].each_with_object({}) do |(_, column), retval|
+          retval[column[:name]] = table_columns[column[:name]] # Same order as ColReordernow
+          retval[column[:name]][:visible] = (column[:visible] == 'true') # As per ColVis
         end
       end
 

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

@@ -15,20 +15,22 @@ module Effective
 
         # Here we identify all belongs_to associations and build up a Hash like:
         # {user: {foreign_key: 'user_id', klass: User}, order: {foreign_key: 'order_id', klass: Effective::Order}}
-        belong_tos = (collection.ancestors.first.reflect_on_all_associations(:belongs_to) rescue []).inject(HashWithIndifferentAccess.new()) do |retval, bt|
-          unless bt.options[:polymorphic]
-            begin
-              klass = bt.klass || bt.foreign_type.sub('_type', '').classify.constantize
-            rescue => e
-              klass = nil
-            end
+        belong_tos = (collection.klass.reflect_on_all_associations(:belongs_to) rescue []).inject({}) do |retval, bt|
+          next if bt.options[:polymorphic]
 
-            retval[bt.name] = {foreign_key: bt.foreign_key, klass: klass} if bt.foreign_key.present? && klass.present?
-          end
+          klass = bt.klass || (bt.foreign_type.sub('_type', '').classify.constantize rescue nil)
+          retval[bt.name.to_s] = {foreign_key: bt.foreign_key, klass: klass} if bt.foreign_key.present? && klass.present?
 
           retval
         end
 
+        # has_manys
+        has_manys = (collection.klass.reflect_on_all_associations(:has_many) rescue []).inject({}) do |retval, hm|
+          klass = hm.klass || (hm.build_association({}).class)
+          retval[hm.name.to_s] = {klass: klass}
+          retval
+        end
+
         table_columns = cols.each_with_index do |(name, _), index|
           # If this is a belongs_to, add an :if clause specifying a collection scope if
           if belong_tos.key?(name)
@@ -45,10 +47,29 @@ module Effective
           cols[name][:label] ||= name.titleize
           cols[name][:column] ||= (sql_table && sql_column) ? "\"#{sql_table.name}\".\"#{sql_column.name}\"" : name
           cols[name][:width] ||= nil
-          cols[name][:sortable] = true if cols[name][:sortable] == nil
-          cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : sql_column.try(:type).presence) || :string
+          cols[name][:sortable] = true if cols[name][:sortable].nil?
+          cols[name][:visible] = true if cols[name][:visible].nil?
+
+          # Type
+          cols[name][:type] ||= (
+            if belong_tos.key?(name)
+              :belongs_to
+            elsif has_manys.key?(name)
+              :has_many
+            elsif sql_column.try(:type).present?
+              sql_column.type
+            else
+              :string # When in doubt
+            end
+          )
+
           cols[name][:class] = "col-#{cols[name][:type]} col-#{name} #{cols[name][:class]}".strip
 
+          # HasMany
+          if cols[name][:type] == :has_many
+            cols[name][:sortable] = false
+          end
+
           # EffectiveObfuscation
           if name == 'id' && defined?(EffectiveObfuscation) && collection.respond_to?(:deobfuscate)
             cols[name][:sortable] = false
@@ -66,7 +87,7 @@ module Effective
             cols[name][:sql_as_column] = true
           end
 
-          cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type], belong_tos[name])
+          cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type], belong_tos[name], has_manys[name])
 
           if cols[name][:partial]
             cols[name][:partial_local] ||= (sql_table.try(:name) || cols[name][:partial].split('/').last(2).first.presence || 'obj').singularize.to_sym
@@ -81,7 +102,7 @@ module Effective
 
       end
 
-      def initialize_table_column_filter(filter, col_type, belongs_to)
+      def initialize_table_column_filter(filter, col_type, belongs_to, has_many)
         return {type: :null} if filter == false
 
         filter = {type: filter.to_sym} if filter.kind_of?(String)
@@ -96,6 +117,12 @@ module Effective
             type: :select,
             values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
           }
+        when :has_many
+          {
+            type: :select,
+            multiple: true,
+            values: Proc.new { has_many[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
+          }
         when :effective_roles
           {type: :select, values: EffectiveRoles.roles}
         when :integer

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

@@ -59,8 +59,8 @@ module Effective
 
         # We want to use the render :collection for each column that renders partials
         rendered = {}
-        table_columns.each do |name, opts|
-          if opts[:partial]
+        (display_table_columns || table_columns).each do |name, opts|
+          if opts[:partial] && opts[:visible]
             locals = {
               datatable: self,
               table_column: table_columns[name],
@@ -84,14 +84,19 @@ module Effective
 
         collection.each_with_index.map do |obj, index|
           (display_table_columns || table_columns).map do |name, opts|
-            value = if opts[:partial]
+            if opts[:visible] == false
+              ''
+            elsif opts[:partial]
               rendered[name][index]
             elsif opts[:block]
               view.instance_exec(obj, collection, self, &opts[:block])
             elsif opts[:proc]
               view.instance_exec(obj, collection, self, &opts[:proc])
             elsif opts[:type] == :belongs_to
-              val = (obj.send(name) rescue nil).to_s
+              (obj.send(name) rescue nil).to_s
+            elsif opts[:type] == :has_many
+              objs = (obj.send(name).map(&:to_s).sort rescue [])
+              objs.length == 1 ? objs.first : (opts[:sentence] ? objs.to_sentence : objs.join('<br>'))
             elsif opts[:type] == :obfuscated_id
               (obj.send(:to_param) rescue nil).to_s
             elsif opts[:type] == :effective_roles
@@ -101,20 +106,9 @@ module Effective
             elsif opts[:type] == :date
               (obj.send(name).strftime(EffectiveDatatables.date_format) rescue nil)
             else
-              val = (obj.send(name) rescue nil)
-              val = (obj[opts[:array_index]] rescue nil) if val == nil
-              val
+              obj.send(name) rescue (obj[opts[:array_index]] rescue nil)
             end
 
-            # Last minute formatting of dates
-            case value
-            when Date
-              value.strftime(EffectiveDatatables.date_format)
-            when Time, DateTime
-              value.strftime(EffectiveDatatables.datetime_format)
-            else
-              value.to_s
-            end
           end
         end
       end

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.0.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-24 00:00:00.000000000 Z
+date: 2015-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails