effective_datatables 2.12.2 → 3.0.0

data/app/models/effective/datatable_column.rb

@@ -0,0 +1,28 @@
+module Effective
+  class DatatableColumn
+    attr_accessor :attributes
+
+    delegate :[], :[]=, to: :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def to_s
+      self[:name]
+    end
+
+    def format(&block)
+      @attributes[:format] = block; self
+    end
+
+    def search(&block)
+      @attributes[:search_method] = block; self
+    end
+
+    def sort(&block)
+      @attributes[:sort_method] = block; self
+    end
+
+  end
+end

data/app/models/effective/datatable_column_tool.rb

@@ -0,0 +1,110 @@
+module Effective
+  class DatatableColumnTool
+    attr_reader :datatable
+    attr_reader :columns
+
+    def initialize(datatable)
+      @datatable = datatable
+
+      if datatable.active_record_collection?
+        @columns = datatable.columns.select { |_, col| col[:sql_column].present? }
+      else
+        @columns = {}
+      end
+    end
+
+    def scoped
+      @scoped ||= datatable._scopes[datatable.scope]
+    end
+
+    def searched
+      @searched ||= datatable.search.select { |name, _| columns.key?(name) }
+    end
+
+    def ordered
+      @ordered_column ||= columns[datatable.order_name]
+    end
+
+    def order(collection)
+      return collection unless ordered.present?
+
+      collection = if ordered[:sort_method]
+        datatable.dsl_tool.instance_exec(collection, datatable.order_direction, ordered, ordered[:sql_column], &ordered[:sort_method])
+      else
+        order_column(collection, datatable.order_direction, ordered, ordered[:sql_column])
+      end
+
+      raise 'sort method must return an ActiveRecord::Relation object' unless collection.kind_of?(ActiveRecord::Relation)
+
+      collection
+    end
+
+    def order_column(collection, direction, column, sql_column)
+      Rails.logger.info "COLUMN TOOL: order_column #{column.to_s} #{direction} #{sql_column}"
+
+      if column[:sql_as_column]
+        collection.order("#{sql_column} #{datatable.resource.sql_direction(direction)}")
+      else
+        Effective::Resource.new(collection)
+          .order(column[:name], direction, as: column[:as], sort: column[:sort], sql_column: column[:sql_column])
+      end
+    end
+
+    def scope(collection)
+      return collection unless scoped.present?
+
+      collection.send(scoped[:name], *scoped[:args])
+    end
+
+    def search(collection)
+      searched.each do |name, value|
+        column = columns[name]
+
+        collection = if column[:search_method]
+          datatable.dsl_tool.instance_exec(collection, value, column, column[:sql_column], &column[:search_method])
+        else
+          search_column(collection, value, column, column[:sql_column])
+        end
+
+        raise 'search method must return an ActiveRecord::Relation object' unless collection.kind_of?(ActiveRecord::Relation)
+      end
+
+      collection
+    end
+
+    def search_column(collection, value, column, sql_column)
+      Rails.logger.info "COLUMN TOOL: search_column #{column.to_s} #{value} #{sql_column}"
+
+      Effective::Resource.new(collection)
+        .search(column[:name], value, as: column[:as], fuzzy: column[:search][:fuzzy], sql_column: sql_column)
+    end
+
+    def paginate(collection)
+      collection.page(datatable.page).per(datatable.per_page)
+    end
+
+    # Not every ActiveRecord query will work when calling the simple .count
+    # Custom selects:
+    #   User.select(:email, :first_name).count will throw an error
+    # Grouped Queries:
+    #   User.all.group(:email).count will return a Hash
+    def size(collection)
+      count = (collection.size rescue nil)
+
+      case count
+      when Integer
+        count
+      when Hash
+        count.size  # This represents the number of displayed datatable rows, not the sum all groups (which might be more)
+      else
+        if collection.klass.connection.respond_to?(:unprepared_statement)
+          collection_sql = collection.klass.connection.unprepared_statement { collection.to_sql }
+          (collection.klass.connection.exec_query("SELECT COUNT(*) FROM (#{collection_sql}) AS datatables_total_count").rows[0][0] rescue 1)
+        else
+          (collection.klass.connection.exec_query("SELECT COUNT(*) FROM (#{collection.to_sql}) AS datatables_total_count").rows[0][0] rescue 1)
+        end.to_i
+      end
+    end
+
+  end
+end

data/app/models/effective/datatable_dsl_tool.rb

@@ -0,0 +1,28 @@
+module Effective
+
+  class DatatableDslTool
+    attr_reader :datatable
+    attr_reader :view
+
+    include Effective::EffectiveDatatable::Dsl::BulkActions
+    include Effective::EffectiveDatatable::Dsl::Charts
+    include Effective::EffectiveDatatable::Dsl::Datatable
+    include Effective::EffectiveDatatable::Dsl::Filters
+
+    def initialize(datatable)
+      @datatable = datatable
+      @view = datatable.view
+    end
+
+    def method_missing(method, *args)
+      if datatable.respond_to?(method)
+        datatable.send(method, *args)
+      elsif view.respond_to?(method)
+        view.send(method, *args)
+      else
+        super
+      end
+    end
+
+  end
+end

data/app/models/effective/datatable_value_tool.rb

@@ -0,0 +1,142 @@
+module Effective
+  # The collection is an Array of Arrays
+  class DatatableValueTool
+    attr_reader :datatable
+    attr_reader :columns
+
+    def initialize(datatable)
+      @datatable = datatable
+
+      if datatable.array_collection?
+        @columns = datatable.columns
+      else
+        @columns = datatable.columns.select { |_, col| col[:sql_column].blank? }
+      end
+    end
+
+    def searched
+      @searched ||= datatable.search.select { |name, _| columns.key?(name) }
+    end
+
+    def ordered
+      @ordered ||= columns[datatable.order_name]
+    end
+
+    def order(collection)
+      return collection unless ordered.present?
+
+      collection = if ordered[:sort_method]
+        datatable.dsl_tool.instance_exec(collection, datatable.order_direction, ordered, ordered[:index], &ordered[:sort_method])
+      else
+        order_column(collection, datatable.order_direction, ordered, ordered[:index])
+      end
+
+      raise 'sort method must return an Array' unless collection.kind_of?(Array)
+
+      collection
+    end
+
+    def order_column(collection, direction, column, index)
+      Rails.logger.info "VALUE TOOL: order_column :#{column.to_s} :#{direction} #{index}"
+
+      if direction == :asc
+        collection.sort! do |x, y|
+          x[index] <=> y[index] || x[index].to_s <=> y[index].to_s || 0
+        end
+      else
+        collection.sort! do |x, y|
+          y[index] <=> x[index] || y[index].to_s <=> x[index].to_s || 0
+        end
+      end
+
+      collection
+    end
+
+    def search(collection)
+      searched.each do |name, value|
+        column = columns[name]
+
+        collection = if column[:search_method]
+          datatable.dsl_tool.instance_exec(collection, value, column, column[:index], &column[:search_method])
+        else
+          search_column(collection, value, column, column[:index])
+        end
+
+        raise 'search method must return an Array object' unless collection.kind_of?(Array)
+      end
+
+      collection
+    end
+
+    def search_column(collection, value, column, index)
+      Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{value} #{index}"
+
+      fuzzy = column[:search][:fuzzy]
+      term = Effective::Attribute.new(column[:as]).parse(value, name: column[:name])
+      term_downcased = term.downcase if fuzzy && term.kind_of?(String)
+
+      if term == 'nil'
+        return (collection.select! { |row| row[index].nil? } || collection)
+      end
+
+      # See effective_resources gem search() method # relation.rb
+      collection.select! do |row|
+        case column[:as]
+        when :duration
+          if fuzzy && (term % 60 == 0) && value.to_s.include?('m') == false
+            if term < 0
+              row[index] <= term && row[index] > (term - 60)
+            else
+              row[index] >= term && row[index] < (term + 60)
+            end
+          else
+            row[index] == term
+          end
+        when :decimal, :currency
+          if fuzzy && (term.round(0) == term) && value.to_s.include?('.') == false
+            if term < 0
+              row[index] <= term && row[index] > (term - 1.0)
+            else
+              row[index] >= term && row[index] < (term + 1.0)
+            end
+          else
+            row[index] == term
+          end
+        when :resource
+          Array(row[index]).any? do |resource|
+            if term.kind_of?(Integer) && resource.respond_to?(:id)
+              resource.id == term || resource.to_param == term
+            elsif term.kind_of?(Array) && resource.respond_to?(:id)
+              term.any? { |term| resource.id == term || resource.to_param == term || resource.to_param == value }
+            else
+              fuzzy ? resource.to_s.downcase == term_downcased : resource.to_s == term
+            end
+          end
+        when :string, :text, :email
+          if fuzzy
+            row[index].to_s.downcase.include?(term_downcased)
+          else
+            row[index] == term
+          end
+        else
+          row[index] == term
+        end
+      end || collection
+    end
+
+    def paginate(collection)
+      Kaminari.paginate_array(collection).page(datatable.page).per(datatable.per_page)
+    end
+
+    def size(collection)
+      collection.size
+    end
+
+  end
+end
+
+# [
+#   [1, 'title 1'],
+#   [2, 'title 2'],
+#   [3, 'title 3']
+# ]

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

@@ -0,0 +1,25 @@
+module Effective
+  module EffectiveDatatable
+    module Attributes
+
+      private
+
+      def initial_attributes(args)
+        raise "#{self.class.name}.new() expected Hash like arguments" unless args.kind_of?(Hash)
+        args
+      end
+
+      def load_attributes!
+        if datatables_ajax_request?
+          raise 'Expected attributes cookie to be present' unless cookie
+          @attributes = cookie[:attributes]
+        end
+
+        unless datatables_ajax_request?
+          @attributes[:controller_namespace] ||= view.controller_path.split('/')[0...-1].join('/').presence
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Effective
+  module EffectiveDatatable
+    module Collection
+
+      # Used for authorization.  We authorize with authorized?(:index, collection_class)
+      def collection_class
+        @collection_class  # Will be either User/Post/etc or Array
+      end
+
+      def active_record_collection?
+        @active_record_collection == true
+      end
+
+      def array_collection?
+        @array_collection == true
+      end
+
+      private
+
+      def load_collection!
+        raise 'No collection defined. Please add a collection with collection do ... end' if collection.nil?
+
+        @collection_class = (collection.respond_to?(:klass) ? collection.klass : self.class)
+        @active_record_collection = (collection.ancestors.include?(ActiveRecord::Base) rescue false)
+        @array_collection = (collection.kind_of?(Array) && (collection.length == 0 || collection.first.kind_of?(Array)))
+
+        unless active_record_collection? || array_collection?
+          raise "Unsupported collection type. Expecting an ActiveRecord class, ActiveRecord relation, or an Array of Arrays [[1, 'foo'], [2, 'bar']]"
+        end
+
+        _scopes.each do |scope, _|
+          raise "invalid scope: :#{scope}. The collection must respond to :#{scope}" unless collection.respond_to?(scope)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+module Effective
+  module EffectiveDatatable
+    module Compute
+      BLANK = ''.freeze
+
+      private
+
+      # So the idea here is that we want to do as much as possible on the database in ActiveRecord
+      # And then run any array_columns through in post-processed results
+      def compute
+        col = collection
+
+        # Assign total records
+        @total_records = (active_record_collection? ? column_tool.size(col) : value_tool.size(col))
+
+        # Apply scope
+        col = column_tool.scope(col)
+
+        # Apply column searching
+        col = column_tool.search(col)
+        @display_records = column_tool.size(col) unless value_tool.searched.present?
+
+        # Apply column ordering
+        col = column_tool.order(col)
+
+        # Arrayize if we have value tool work to do
+        col = arrayize(col) if value_tool.searched.present? || value_tool.ordered.present?
+
+        # Apply value searching
+        col = value_tool.search(col)
+        @display_records = value_tool.size(col) if value_tool.searched.present?
+
+        # Apply value ordering
+        col = value_tool.order(col)
+
+        # Apply pagination
+        col = col.kind_of?(Array) ? value_tool.paginate(col) : column_tool.paginate(col)
+
+        # Arrayize the searched, ordered, paginated results
+        col = arrayize(col) unless col.kind_of?(Array)
+
+        # Assign display records
+        @display_records ||= @total_records
+
+        # Compute aggregate data
+        @aggregates_data = aggregate(col) if _aggregates.present?
+
+        # Charts too
+        @charts_data = chart(col) if _charts.present?
+
+        # Format all results
+        format(col)
+
+        # Finalize hook
+        finalize(col)
+      end
+
+      def arrayize(collection)
+        collection.map do |obj|
+          columns.map do |name, opts|
+            if state[:visible][name] == false && (name != order_name)  # Sort by invisible array column
+              BLANK
+            elsif opts[:partial] || (opts[:format] && !opts[:compute])
+              active_record_collection? ? obj : obj[opts[:index]]
+            elsif opts[:compute]
+              dsl_tool.instance_exec(obj, (active_record_collection? ? collection : obj[opts[:index]]), &opts[:compute])
+            elsif opts[:as] == :effective_obfuscation
+              obj.to_param
+            elsif array_collection?
+              obj[opts[:index]]
+            elsif opts[:sql_as_column]
+              obj[name] || obj.send(name)
+            else
+              obj.send(name)
+            end
+          end
+        end
+      end
+
+      def aggregate(collection)
+        cols = collection.transpose
+
+        _aggregates.map do |_, aggregate|
+          columns.map do |name, opts|
+            next if state[:visible][name] == false && datatables_ajax_request?
+
+            values = cols[opts[:index]] || []
+
+            if state[:visible][name] == false
+              BLANK
+            elsif aggregate[:compute]
+              dsl_tool.instance_exec(values, columns[name], &aggregate[:compute])
+            else
+              format_column(aggregate_column(values, opts, aggregate), opts)
+            end
+          end.compact
+        end
+      end
+
+      def aggregate_column(values, column, aggregate)
+        labeled = false
+        length = values.length
+        values = values.reject { |value| value.nil? }
+
+        if [:bulk_actions, :actions].include?(column[:as]) || length == 0
+          return BLANK
+        end
+
+        case aggregate[:name]
+        when :total
+          if values.all? { |value| value.kind_of?(Numeric) }
+            values.sum
+          elsif values.all? { |value| value == true || value == false }
+            "#{values.count { |val| val == true }} / #{values.count { |val| val == false}}"
+          elsif !labeled
+            labeled = aggregate[:label]
+          elsif values.any? { |value| value.kind_of?(String) == false }
+            "#{values.flatten.count} total"
+          end
+        when :average
+          if values.all? { |value| value.kind_of?(Numeric) }
+            values.sum / [length, 1].max
+          elsif values.all? { |value| value == true || value == false }
+            values.count { |val| val == true } >= (length / 2) ? true : false
+          elsif !labeled
+            labeled = aggregate[:label]
+          elsif values.any? { |value| value.kind_of?(String) == false }
+            '-'
+          end
+        else
+          raise 'not implemented'
+        end || BLANK
+      end
+
+      def chart(collection)
+        _charts.inject({}) do |retval, (name, chart)|
+          retval[name] = {
+            as: chart[:as],
+            data: dsl_tool.instance_exec(collection, &chart[:compute]),
+            name: chart[:name],
+            options: chart[:options]
+          }
+
+          unless retval[name][:data].kind_of?(Array) && retval[name][:data].first.kind_of?(Array)
+            raise "invalid chart :#{name}. The block must return an Array of Arrays"
+          end
+
+          retval
+        end
+      end
+
+    end
+  end
+end