effective_datatables 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 104ed4736f57500cb86aaa07631d96aa36b4df8d
-  data.tar.gz: 800891f688c2e363b19336e19896ba0fa5900ecb
+  metadata.gz: e5dd14893bb1a01f311ccb678ab2ab199177d7c6
+  data.tar.gz: 0dca76ae65b7c576ccdb3bdb2eba5e30ab00b44d
 SHA512:
-  metadata.gz: 1b70a5c78893a581b4db8bc277196c37e19b5fe1d4ea2eb5025868aee2512e071b8cfb9ce1ef0f3ec4f8e2ffb1ba363eae7c6d24db6fd7291838c653b2076fb9
-  data.tar.gz: 066e62e1d2a348dfe780f59b2405284c7707a00985ed3db03166b542e8ddce4fe82110ea3feddc911241489f47411026c490271627c6cff7985b696e1a0484c7
+  metadata.gz: 34f5a501b53fa8be7ce46dd44522b045534e4c8e6c51c68c2b77f03e3326b09bf8d7fdea6e7fb27949607b4b5e9dd3a21d7f49bee22fea48b62bbb2ec635f5fc
+  data.tar.gz: f2bf133e9d2b309d4eb199a61fbb402138c7f945879796832237541b36759592728486497269d2b4448b9437e8f12edbc9f4980d0297f849583c44f252523ea1

data/README.md

@@ -346,6 +346,7 @@ Some additional, lesser used options include:
 
 ```ruby
 :filter => {:fuzzy => true} # Will use an ILIKE/includes rather than = when filtering.  Use this for selects.
+:filter => {sql_operation => :having}  # Will use .having() instead of .where() to handle aggregate columns (autodetected)
 ```
 
 ### Rendering Options

data/app/models/effective/active_record_datatable_tool.rb

@@ -38,13 +38,14 @@ module Effective
 
     def search_column_with_defaults(collection, table_column, term)
       column = table_column[:column]
+      sql_op = table_column[:filter][:sql_operation] || :where # only other option is :having
 
       case table_column[:type]
       when :string, :text
-        if table_column[:filter][:type] == :select && table_column[:filter][:fuzzy] != true
-          collection.where("#{column} = :term", term: term)
+        if (table_column[:filter][:type] == :select && table_column[:filter][:fuzzy] != true) || sql_op != :where
+          collection.public_send(sql_op, "#{column} = :term", term: term)
         else
-          collection.where("#{column} ILIKE :term", term: "%#{term}%")
+          collection.public_send(sql_op, "#{column} ILIKE :term", term: "%#{term}%")
         end
       when :has_many
         inverse_ids = term.split(',').map { |term| (term = term.to_i) == 0 ? nil : term }.compact
@@ -61,7 +62,15 @@ module Effective
 
         ids = klass.where(id: inverse_ids).joins(inverse.name).pluck(inverse.foreign_key)
 
-        collection.where(id: ids)
+        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
+          collection.public_send(sql_op, "#{column} = :term", term: 0)
+        else
+          collection.public_send(sql_op, "#{column} = :term", term: deobfuscated_id)
+        end
+      when :effective_roles
+        collection.with_role(term)
       when :datetime, :date
         begin
           digits = term.scan(/(\d+)/).flatten.map(&:to_i)
@@ -84,29 +93,21 @@ module Effective
             end_at = start_at
           end
 
-          collection.where("#{column} >= :start_at AND #{column} <= :end_at", start_at: start_at, end_at: end_at)
+          collection.public_send(sql_op, "#{column} >= :start_at AND #{column} <= :end_at", start_at: start_at, end_at: end_at)
         rescue => e
           collection
         end
-      when :obfuscated_id
-        if (deobfuscated_id = collection.deobfuscate(term)) == term # We weren't able to deobfuscate it, so this is an Invalid ID
-          collection.where("#{column} = :term", term: 0)
-        else
-          collection.where("#{column} = :term", term: deobfuscated_id)
-        end
-      when :effective_roles
-        collection.with_role(term)
       when :integer
-        collection.where("#{column} = :term", term: term.to_i)
+        collection.public_send(sql_op, "#{column} = :term", term: term.to_i)
       when :year
-        collection.where("EXTRACT(YEAR FROM #{column}) = :term", term: term.to_i)
+        collection.public_send(sql_op, "EXTRACT(YEAR FROM #{column}) = :term", term: term.to_i)
       when :price
         price_in_cents = (term.gsub(/[^0-9|\.]/, '').to_f * 100.0).to_i
-        collection.where("#{column} = :term", term: price_in_cents)
+        collection.public_send(sql_op, "#{column} = :term", term: price_in_cents)
       when :currency
-        collection.where("#{column} = :term", term: term.gsub(/[^0-9|\.]/, '').to_f)
+        collection.public_send(sql_op, "#{column} = :term", term: term.gsub(/[^0-9|\.]/, '').to_f)
       else
-        collection.where("#{column} = :term", term: term)
+        collection.public_send(sql_op, "#{column} = :term", term: term)
       end
     end
 

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

@@ -87,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], has_manys[name])
+          cols[name][:filter] = initialize_table_column_filter(cols[name], 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
@@ -102,7 +102,11 @@ module Effective
 
       end
 
-      def initialize_table_column_filter(filter, col_type, belongs_to, has_many)
+      def initialize_table_column_filter(column, belongs_to, has_many)
+        filter = column[:filter]
+        col_type = column[:type]
+        sql_column = column[:column].to_s.upcase
+
         return {type: :null} if filter == false
 
         filter = {type: filter.to_sym} if filter.kind_of?(String)
@@ -111,17 +115,22 @@ module Effective
         # This is a fix for passing filter[:selected] == false, it needs to be 'false'
         filter[:selected] = filter[:selected].to_s unless filter[:selected].nil?
 
+        # Check if this is an aggregate column
+        if ['SUM(', 'COUNT(', 'MAX(', 'MIN(', 'AVG('].any? { |str| sql_column.include?(str) }
+          filter[:sql_operation] = :having
+        end
+
         case col_type
         when :belongs_to
           {
             type: :select,
-            values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
+            values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
           }
         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] } }
+            values: Proc.new { has_many[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
           }
         when :effective_roles
           {type: :select, values: EffectiveRoles.roles}

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

@@ -95,27 +95,32 @@ module Effective
             elsif opts[:type] == :belongs_to
               (obj.send(name) rescue nil).to_s
             elsif opts[:type] == :has_many
-              objs = (obj.send(name).map(&:to_s).sort rescue [])
+              objs = (obj.send(name).map { |x| x.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
               (obj.send(:roles) rescue []).join(', ')
-            elsif opts[:type] == :datetime
-              (obj.send(name).strftime(EffectiveDatatables.datetime_format) rescue nil)
-            elsif opts[:type] == :date
-              (obj.send(name).strftime(EffectiveDatatables.date_format) rescue nil)
-            elsif opts[:type] == :price
-              # This is price_to_currency from effective_form_inputs retyped...
-              price = ((obj.send(name) || 0) rescue 0)
-              raise 'column type: price expects an Integer representing the number of cents' unless price.kind_of?(Integer)
-              number_to_currency(price / 100.0)
-            elsif opts[:type] == :currency
-              number_to_currency(((obj.send(name) || 0) rescue 0))
             else
-              obj.send(name) rescue (obj[opts[:array_index]] rescue nil)
+              # Normal value, but we still may want to format it
+              value = (obj.send(name) rescue nil) || (obj[name] rescue nil) || (obj[opts[:array_index]] rescue nil)
+
+              case opts[:type]
+              when :datetime
+                value.strftime(EffectiveDatatables.datetime_format) rescue nil
+              when :date
+                value.strftime(EffectiveDatatables.date_format) rescue nil
+              when :price
+                # This is an integer value, "number of cents"
+                value ||= 0
+                raise 'column type: price expects an Integer representing the number of cents' unless value.kind_of?(Integer)
+                number_to_currency(value / 100.0)
+              when :currency
+                number_to_currency(value || 0)
+              else
+                value
+              end
             end
-
           end
         end
       end

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.0.4'.freeze
+  VERSION = '2.0.5'.freeze
 end

metadata

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