effective_datatables 2.3.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 008015d3e0eee31f97cee6a004c806fb52fbb2d5
-  data.tar.gz: 3cd65ca8bd24f4dff5fcda583fddce94a3e64544
+  metadata.gz: f1a04998ee9c940102f9df4a951d72bce9e4df41
+  data.tar.gz: 8344057c6f04c15bdf157b1e712634a3ffcaf73d
 SHA512:
-  metadata.gz: 424ebcf833f830200a85057ca79e83b1ee6f43892cb91a1fcc688e9877ea01b231499097a05083183ee9677adf18697da0ac3e851982999c2e6166396de21471
-  data.tar.gz: 6a1c85b2c91d434a5ec3fb83b3c9f39ca976d5684612b01be1981c58919ae03aed7acd7fbee05b312095d6724a70efa505901aff25e2bb95549c5615afea2888
+  metadata.gz: 49182f2222e7299401a32bbc36ed197fe3e4e3ed08d3811f4b0136f3e99216172ae6240bde97b255ed9aec62b1702c785494da8f69a610f834da6699a432d951
+  data.tar.gz: 827c9fdd9c2ed56210216634e480e1a857283a67d59005dda710ac59fb3db237ca9e4a718dbfa1553583cc80d3fbb83fded0aaaae24611796ade1b1f62e6af84

data/app/models/effective/active_record_datatable_tool.rb

@@ -100,6 +100,38 @@ module Effective
           klass.where(conditions.join(' OR '), term: "%#{term}%", num: term.to_i).joins(inverse.name).pluck(inverse.foreign_key)
         end
 
+        collection.public_send(sql_op, id: ids)
+
+      when :has_and_belongs_to_many
+        reflection = collection.klass.reflect_on_association(table_column[:name].to_sym)
+        raise "unable to find #{collection.klass.name} :has_and_belongs_to_many :#{table_column[:name]} association" unless reflection
+
+        obj = reflection.build_association({})
+        klass = obj.class
+
+        inverse = reflection.inverse_of || klass.reflect_on_association(collection.table_name) || obj.class.reflect_on_association(collection.table_name.singularize)
+        raise "unable to find #{klass.name} has_and_belongs_to_many :#{collection.table_name} or belongs_to :#{collection.table_name.singularize} associations" unless inverse
+
+        ids = if [:select, :grouped_select].include?(table_column[:filter][:type])
+          # Treat the search term as one or more IDs
+          inverse_ids = term.split(',').map { |term| (term = term.to_i) == 0 ? nil : term }.compact
+          return collection unless inverse_ids.present?
+
+          klass.where(id: inverse_ids).flat_map { |klass| (klass.send(inverse.name).pluck(:id) rescue []) }
+        else
+          # Treat the search term as a string.
+
+          klass_columns = if (table_column[:column] == klass.table_name) # No custom column has been defined
+            klass.columns.map { |col| col.name if col.text? }.compact  # Search all database text? columns
+          else
+            [table_column[:column].gsub("#{klass.table_name}.", '')] # table_column :order_items, column: 'order_items.title'
+          end
+
+          conditions = klass_columns.map { |col_name| "#{klass.table_name}.#{col_name} #{ilike} :term" }
+
+          klass.where(conditions.join(' OR '), term: "%#{term}%", num: term.to_i).flat_map { |klass| (klass.send(inverse.name).pluck(:id) rescue []) }
+        end
+
         collection.public_send(sql_op, id: ids)
       when :obfuscated_id
         if (deobfuscated_id = collection.deobfuscate(term)) == term # We weren't able to deobfuscate it, so this is an Invalid ID

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

@@ -30,11 +30,18 @@ module Effective
           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
+        # Figure out has_manys and has_many_belongs_to_many's
+        has_manys = {}
+        has_and_belongs_to_manys = {}
+
+        (collection.klass.reflect_on_all_associations() rescue []).each do |reflect|
+          if reflect.macro == :has_many
+            klass = reflect.klass || (reflect.build_association({}).class)
+            has_manys[reflect.name.to_s] = { klass: klass }
+          elsif reflect.macro == :has_and_belongs_to_many
+            klass = reflect.klass || (reflect.build_association({}).class)
+            has_and_belongs_to_manys[reflect.name.to_s] = { klass: klass }
+          end
         end
 
         table_columns = cols.each_with_index do |(name, _), index|
@@ -68,6 +75,8 @@ module Effective
               end
             elsif has_manys.key?(name)
               :has_many
+            elsif has_and_belongs_to_manys.key?(name)
+              :has_and_belongs_to_many
             elsif cols[name][:bulk_actions_column]
               :bulk_actions_column
             elsif name.include?('_address') && (collection_class.new rescue nil).respond_to?(:effective_addresses)
@@ -105,7 +114,7 @@ module Effective
             cols[name][:sql_as_column] = true
           end
 
-          cols[name][:filter] = initialize_table_column_filter(cols[name], belong_tos[name], has_manys[name])
+          cols[name][:filter] = initialize_table_column_filter(cols[name], belong_tos[name], has_manys[name], has_and_belongs_to_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
@@ -127,7 +136,7 @@ module Effective
         end
       end
 
-      def initialize_table_column_filter(column, belongs_to, has_many)
+      def initialize_table_column_filter(column, belongs_to, has_many, has_and_belongs_to_manys)
         filter = column[:filter]
         col_type = column[:type]
         sql_column = column[:column].to_s.upcase
@@ -181,6 +190,18 @@ module Effective
               end
             )
           }
+        when :has_and_belongs_to_many
+          {
+            type: :select,
+            multiple: true,
+            values: (
+              if has_and_belongs_to_manys[:klass].respond_to?(:datatables_filter)
+                Proc.new { has_and_belongs_to_manys[:klass].datatables_filter }
+              else
+                Proc.new { has_and_belongs_to_manys[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
+              end
+            )
+          }
         when :effective_address
           {type: :string}
         when :effective_roles

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

@@ -119,7 +119,9 @@ module Effective
             elsif opts[:type] == :belongs_to_polymorphic
               (obj.send(name) rescue nil)
             elsif opts[:type] == :has_many
-              (obj.send(name).to_a rescue [])
+              (obj.send(name).map { |obj| obj.to_s }.join('<br>') rescue BLANK)
+            elsif opts[:type] == :has_and_belongs_to_many
+              (obj.send(name).map { |obj| obj.to_s }.join('<br>') rescue BLANK)
             elsif opts[:type] == :bulk_actions_column
               BLANK
             elsif opts[:type] == :obfuscated_id

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.3.1'.freeze
+  VERSION = '2.3.2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.3.2
 platform: ruby
 authors:
 - Code and Effect