ajax-datatables-rails 0.3.1 → 1.3.1

data/lib/ajax-datatables-rails/base.rb

@@ -1,214 +1,159 @@
+# frozen_string_literal: true
+
 module AjaxDatatablesRails
   class Base
-    extend Forwardable
-    class MethodNotImplementedError < StandardError; end
 
-    attr_reader :view, :options, :sortable_columns, :searchable_columns
-    def_delegator :@view, :params, :params
+    class_attribute :db_adapter, default: ::ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+    class_attribute :nulls_last, default: false
 
-    def initialize(view, options = {})
-      @view = view
-      @options = options
-      load_paginator
-    end
+    attr_reader :params, :options, :datatable
 
-    def config
-      @config ||= AjaxDatatablesRails.config
-    end
+    GLOBAL_SEARCH_DELIMITER = ' '
 
-    def sortable_columns
-      @sortable_columns ||= []
+    def initialize(params, options = {})
+      @params    = params
+      @options   = options
+      @datatable = Datatable::Datatable.new(self)
     end
 
-    def searchable_columns
-      @searchable_columns ||= []
-    end
-
-    def data
-      fail(
-        MethodNotImplementedError,
-        'Please implement this method in your class.'
-      )
+    # User defined methods
+    def view_columns
+      raise(NotImplementedError, view_columns_error_text)
     end
 
     def get_raw_records
-      fail(
-        MethodNotImplementedError,
-        'Please implement this method in your class.'
-      )
+      raise(NotImplementedError, raw_records_error_text)
     end
 
-    def as_json(options = {})
-      {
-        :draw => params[:draw].to_i,
-        :recordsTotal =>  get_raw_records.count(:all),
-        :recordsFiltered => filter_records(get_raw_records).count(:all),
-        :data => data
-      }
-    end
-
-    def self.deprecated(message, caller = Kernel.caller[1])
-      warning = caller + ": " + message
-
-      if(respond_to?(:logger) && logger.present?)
-        logger.warn(warning)
-      else
-        warn(warning)
-      end
+    def data
+      raise(NotImplementedError, data_error_text)
     end
 
-    private
-
-    def records
-      @records ||= fetch_records
+    # ORM defined methods
+    def fetch_records
+      get_raw_records
     end
 
-    def fetch_records
-      records = get_raw_records
-      records = sort_records(records) if params[:order].present?
-      records = filter_records(records) if params[:search].present?
-      records = paginate_records(records) unless params[:length].present? && params[:length] == '-1'
-      records
+    def filter_records(records)
+      raise(NotImplementedError)
     end
 
     def sort_records(records)
-      sort_by = []
-      params[:order].each_value do |item|
-        sort_by << "#{sort_column(item)} #{sort_direction(item)}"
-      end
-      records.order(sort_by.join(", "))
+      raise(NotImplementedError)
     end
 
     def paginate_records(records)
-      fail(
-        MethodNotImplementedError,
-        'Please mixin a pagination extension.'
-      )
+      raise(NotImplementedError)
     end
 
-    def filter_records(records)
-      records = simple_search(records)
-      records = composite_search(records)
-      records
+    # User overides
+    def additional_data
+      {}
     end
 
-    def simple_search(records)
-      return records unless (params[:search].present? && params[:search][:value].present?)
-      conditions = build_conditions_for(params[:search][:value])
-      records = records.where(conditions) if conditions
-      records
+    # JSON structure sent to jQuery DataTables
+    def as_json(*)
+      {
+        recordsTotal:    records_total_count,
+        recordsFiltered: records_filtered_count,
+        data:            sanitize_data(data),
+      }.merge(additional_data)
     end
 
-    def composite_search(records)
-      conditions = aggregate_query
-      records = records.where(conditions) if conditions
-      records
+    # User helper methods
+    def column_id(name)
+      view_columns.keys.index(name.to_sym)
     end
 
-    def build_conditions_for(query)
-      search_for = query.split(' ')
-      criteria = search_for.inject([]) do |criteria, atom|
-        criteria << searchable_columns.map { |col| search_condition(col, atom) }.reduce(:or)
-      end.reduce(:and)
-      criteria
+    def column_data(column)
+      id = column_id(column)
+      params.dig('columns', id.to_s, 'search', 'value')
     end
 
-    def search_condition(column, value)
-      if column[0] == column.downcase[0]
-        ::AjaxDatatablesRails::Base.deprecated '[DEPRECATED] Using table_name.column_name notation is deprecated. Please refer to: https://github.com/antillas21/ajax-datatables-rails#searchable-and-sortable-columns-syntax'
-        return deprecated_search_condition(column, value)
-      else
-        return new_search_condition(column, value)
-      end
-    end
+    private
 
-    def new_search_condition(column, value)
-      model, column = column.split('.')
-      model = model.constantize
-      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
-      casted_column.matches("%#{value}%")
+    # helper methods
+    def connected_columns
+      @connected_columns ||= begin
+        view_columns.keys.map do |field_name|
+          datatable.column_by(:data, field_name.to_s)
+        end.compact
+      end
     end
 
-    def deprecated_search_condition(column, value)
-      model, column = column.split('.')
-      model = model.singularize.titleize.gsub( / /, '' ).constantize
-
-      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
-      casted_column.matches("%#{value}%")
+    def searchable_columns
+      @searchable_columns ||= begin
+        connected_columns.select(&:searchable?)
+      end
     end
 
-    def aggregate_query
-      conditions = searchable_columns.each_with_index.map do |column, index|
-        value = params[:columns]["#{index}"][:search][:value] if params[:columns]
-        search_condition(column, value) unless value.blank?
+    def search_columns
+      @search_columns ||= begin
+        searchable_columns.select(&:searched?)
       end
-      conditions.compact.reduce(:and)
     end
 
-    def typecast
-      case config.db_adapter
-      when :oracle then 'VARCHAR2(4000)'  
-      when :pg then 'VARCHAR'
-      when :mysql2 then 'CHAR'
-      when :sqlite3 then 'TEXT'
+    def sanitize_data(data)
+      data.map do |record|
+        if record.is_a?(Array)
+          record.map { |td| ERB::Util.html_escape(td) }
+        else
+          record.update(record) { |_, v| ERB::Util.html_escape(v) }
+        end
       end
     end
 
-    def offset
-      (page - 1) * per_page
+    # called from within #data
+    def records
+      @records ||= retrieve_records
     end
 
-    def page
-      (params[:start].to_i / per_page) + 1
+    def retrieve_records
+      records = fetch_records
+      records = filter_records(records)
+      records = sort_records(records)     if datatable.orderable?
+      records = paginate_records(records) if datatable.paginate?
+      records
     end
 
-    def per_page
-      params.fetch(:length, 10).to_i
+    def records_total_count
+      fetch_records.count(:all)
     end
 
-    def sort_column(item)
-      new_sort_column(item)
-    rescue
-      ::AjaxDatatablesRails::Base.deprecated '[DEPRECATED] Using table_name.column_name notation is deprecated. Please refer to: https://github.com/antillas21/ajax-datatables-rails#searchable-and-sortable-columns-syntax'
-      deprecated_sort_column(item)
+    def records_filtered_count
+      filter_records(fetch_records).count(:all)
     end
 
-    def deprecated_sort_column(item)
-      sortable_columns[sortable_displayed_columns.index(item[:column])]
+    def global_search_delimiter
+      GLOBAL_SEARCH_DELIMITER
     end
 
-    def new_sort_column(item)
-      model, column = sortable_columns[sortable_displayed_columns.index(item[:column])].split('.')
-      col = [model.constantize.table_name, column].join('.')
-    end
+    def raw_records_error_text
+      <<-ERROR
 
-    def sort_direction(item)
-      options = %w(desc asc)
-      options.include?(item[:dir]) ? item[:dir].upcase : 'ASC'
+        You should implement this method in your class and specify
+        how records are going to be retrieved from the database.
+      ERROR
     end
 
-    def sortable_displayed_columns
-      @sortable_displayed_columns ||= generate_sortable_displayed_columns
-    end
+    def data_error_text
+      <<-ERROR
 
-    def generate_sortable_displayed_columns
-      @sortable_displayed_columns = []
-      params[:columns].each_value do |column|
-        @sortable_displayed_columns << column[:data] if column[:orderable] == 'true'
-      end
-      @sortable_displayed_columns
+        You should implement this method in your class and return an array
+        of arrays, or an array of hashes, as defined in the jQuery.dataTables
+        plugin documentation.
+      ERROR
     end
 
-    def load_paginator
-      case config.paginator
-      when :kaminari
-        extend Extensions::Kaminari
-      when :will_paginate
-        extend Extensions::WillPaginate
-      else
-        extend Extensions::SimplePaginator
-      end
-      self
+    def view_columns_error_text
+      <<-ERROR
+
+        You should implement this method in your class and return an array
+        of database columns based on the columns displayed in the HTML view.
+        These columns should be represented in the ModelName.column_name,
+        or aliased_join_table.column_name notation.
+      ERROR
     end
+
   end
 end

data/lib/ajax-datatables-rails/datatable/column/date_filter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+      module DateFilter
+
+        RANGE_DELIMITER = '-'
+
+        class DateRange
+          attr_reader :begin, :end
+
+          def initialize(date_start, date_end)
+            @begin = date_start
+            @end   = date_end
+          end
+
+          def exclude_end?
+            false
+          end
+        end
+
+        # Add delimiter option to handle range search
+        def delimiter
+          @delimiter ||= @view_column.fetch(:delimiter, RANGE_DELIMITER)
+        end
+
+        # A range value is in form '<range_start><delimiter><range_end>'
+        # This returns <range_start>
+        def range_start
+          @range_start ||= formatted_value.split(delimiter)[0]
+        end
+
+        # A range value is in form '<range_start><delimiter><range_end>'
+        # This returns <range_end>
+        def range_end
+          @range_end ||= formatted_value.split(delimiter)[1]
+        end
+
+        def empty_range_search?
+          (formatted_value == delimiter) || (range_start.blank? && range_end.blank?)
+        end
+
+        # Do a range search
+        def date_range_search
+          return nil if empty_range_search?
+
+          table[field].between(DateRange.new(range_start_casted, range_end_casted))
+        end
+
+        private
+
+        def range_start_casted
+          range_start.blank? ? parse_date('01/01/1970') : parse_date(range_start)
+        end
+
+        def range_end_casted
+          range_end.blank? ? parse_date('9999-12-31 23:59:59') : parse_date("#{range_end} 23:59:59")
+        end
+
+        def parse_date(date)
+          Time.zone ? Time.zone.parse(date) : Time.parse(date)
+        end
+
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/datatable/column/order.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+      module Order
+
+        def orderable?
+          @view_column.fetch(:orderable, true)
+        end
+
+        # Add sort_field option to allow overriding of sort field
+        def sort_field
+          @view_column.fetch(:sort_field, field)
+        end
+
+        def sort_query
+          custom_field? ? source : "#{table.name}.#{sort_field}"
+        end
+
+        # Add option to sort null values last
+        def nulls_last?
+          @view_column.fetch(:nulls_last, false)
+        end
+
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/datatable/column/search.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+      module Search
+
+        SMALLEST_PQ_INTEGER = -2_147_483_648
+        LARGEST_PQ_INTEGER  = 2_147_483_647
+        NOT_NULL_VALUE      = '!NULL'
+        EMPTY_VALUE         = ''
+
+        def searchable?
+          @view_column.fetch(:searchable, true)
+        end
+
+        def cond
+          @view_column.fetch(:cond, :like)
+        end
+
+        def filter
+          @view_column[:cond].call(self, formatted_value)
+        end
+
+        def search
+          @search ||= SimpleSearch.new(options[:search])
+        end
+
+        def searched?
+          search.value.present?
+        end
+
+        def search_query
+          search.regexp? ? regex_search : non_regex_search
+        end
+
+        # Add use_regex option to allow bypassing of regex search
+        def use_regex?
+          @view_column.fetch(:use_regex, true)
+        end
+
+        private
+
+        # Using multi-select filters in JQuery Datatable auto-enables regex_search.
+        # Unfortunately regex_search doesn't work when filtering on primary keys with integer.
+        # It generates this kind of query : AND ("regions"."id" ~ '2|3') which throws an error :
+        # operator doesn't exist : integer ~ unknown
+        # The solution is to bypass regex_search and use non_regex_search with :in operator
+        def regex_search
+          if use_regex?
+            ::Arel::Nodes::Regexp.new((custom_field? ? field : table[field]), ::Arel::Nodes.build_quoted(formatted_value))
+          else
+            non_regex_search
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def non_regex_search
+          case cond
+          when Proc
+            filter
+          when :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in
+            searchable_integer? ? raw_search(cond) : empty_search
+          when :start_with
+            text_search("#{formatted_value}%")
+          when :end_with
+            text_search("%#{formatted_value}")
+          when :like
+            text_search("%#{formatted_value}%")
+          when :string_eq
+            raw_search(:eq)
+          when :string_in
+            raw_search(:in)
+          when :null_value
+            null_value_search
+          when :date_range
+            date_range_search
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def null_value_search
+          if formatted_value == NOT_NULL_VALUE
+            table[field].not_eq(nil)
+          else
+            table[field].eq(nil)
+          end
+        end
+
+        def raw_search(cond)
+          if custom_field?
+            ::Arel::Nodes::SqlLiteral.new(field).eq(formatted_value)
+          else
+            table[field].send(cond, formatted_value)
+          end
+        end
+
+        def text_search(value)
+          casted_column.matches(value)
+        end
+
+        def empty_search
+          casted_column.matches(EMPTY_VALUE)
+        end
+
+        def searchable_integer?
+          if formatted_value.is_a?(Array)
+            valids = formatted_value.map { |v| integer?(v) && !out_of_range?(v) }
+            !valids.include?(false)
+          else
+            integer?(formatted_value) && !out_of_range?(formatted_value)
+          end
+        end
+
+        def out_of_range?(search_value)
+          Integer(search_value) > LARGEST_PQ_INTEGER || Integer(search_value) < SMALLEST_PQ_INTEGER
+        end
+
+        def integer?(string)
+          Integer(string)
+          true
+        rescue ArgumentError
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/datatable/column.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+
+      include Search
+      include Order
+      include DateFilter
+
+      attr_reader :datatable, :index, :options
+      attr_writer :search
+
+      def initialize(datatable, index, options)
+        @datatable   = datatable
+        @index       = index
+        @options     = options
+        @view_column = datatable.view_columns[column_name]
+        validate_settings!
+      end
+
+      def column_name
+        @column_name ||= options[:data]&.to_sym
+      end
+
+      def data
+        options[:data].presence || options[:name]
+      end
+
+      def source
+        @view_column[:source]
+      end
+
+      def table
+        model.respond_to?(:arel_table) ? model.arel_table : model
+      end
+
+      def model
+        @model ||= source.split('.').first.constantize
+      end
+
+      def field
+        @field ||= source.split('.').last.to_sym
+      end
+
+      def custom_field?
+        !source.include?('.')
+      end
+
+      # Add formatter option to allow modification of the value
+      # before passing it to the database
+      def formatter
+        @view_column[:formatter]
+      end
+
+      def formatted_value
+        formatter ? formatter.call(search.value) : search.value
+      end
+
+      private
+
+      TYPE_CAST_DEFAULT   = 'VARCHAR'
+      TYPE_CAST_MYSQL     = 'CHAR'
+      TYPE_CAST_SQLITE    = 'TEXT'
+      TYPE_CAST_ORACLE    = 'VARCHAR2(4000)'
+      TYPE_CAST_SQLSERVER = 'VARCHAR(4000)'
+
+      DB_ADAPTER_TYPE_CAST = {
+        mysql:          TYPE_CAST_MYSQL,
+        mysql2:         TYPE_CAST_MYSQL,
+        sqlite:         TYPE_CAST_SQLITE,
+        sqlite3:        TYPE_CAST_SQLITE,
+        oracle:         TYPE_CAST_ORACLE,
+        oracleenhanced: TYPE_CAST_ORACLE,
+        sqlserver:      TYPE_CAST_SQLSERVER,
+      }.freeze
+
+      private_constant :TYPE_CAST_DEFAULT
+      private_constant :TYPE_CAST_MYSQL
+      private_constant :TYPE_CAST_SQLITE
+      private_constant :TYPE_CAST_ORACLE
+      private_constant :TYPE_CAST_SQLSERVER
+      private_constant :DB_ADAPTER_TYPE_CAST
+
+      def type_cast
+        @type_cast ||= DB_ADAPTER_TYPE_CAST.fetch(datatable.db_adapter, TYPE_CAST_DEFAULT)
+      end
+
+      def casted_column
+        @casted_column ||= ::Arel::Nodes::NamedFunction.new('CAST', [table[field].as(type_cast)])
+      end
+
+      def validate_settings!
+        raise AjaxDatatablesRails::Error::InvalidSearchColumn, "Unknown column. Check that `data` field is filled on JS side with the column name" if column_name.empty?
+        raise AjaxDatatablesRails::Error::InvalidSearchColumn, "Check that column '#{column_name}' exists in view_columns" unless valid_search_column?(column_name)
+        raise AjaxDatatablesRails::Error::InvalidSearchCondition, cond unless valid_search_condition?(cond)
+      end
+
+      def valid_search_column?(column_name)
+        !datatable.view_columns[column_name].nil?
+      end
+
+      VALID_SEARCH_CONDITIONS = [
+        # String condition
+        :start_with, :end_with, :like, :string_eq, :string_in, :null_value,
+        # Numeric condition
+        :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in,
+        # Date condition
+        :date_range
+      ].freeze
+
+      private_constant :VALID_SEARCH_CONDITIONS
+
+      def valid_search_condition?(cond)
+        return true if cond.is_a?(Proc)
+
+        VALID_SEARCH_CONDITIONS.include?(cond)
+      end
+
+    end
+  end
+end