Module: DataTable::ActiveRecord::ClassMethods

Defined in:
lib/data_table/active_record.rb

Instance Method Summary collapse

Instance Method Details

#_date_where_condition(query, field) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/data_table/active_record.rb', line 78

def _date_where_condition query, field
  begin
    ["#{field} = ?", Date.parse(query)]
  rescue ArgumentError
    []
  end
end

#_discover_joins(fields) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/data_table/active_record.rb', line 16

def _discover_joins fields
  joins = Set.new
  object = self.new

  fields.each { |it|
    field = it.split('.')

    if (field.size == 2) then
      next if object.class.name.downcase == field[0].singularize

      if object.respond_to?(field[0].to_sym)
        joins.add field[0].to_sym
      elsif object.respond_to?(field[0].singularize.to_sym)
        joins.add field[0].singularize.to_sym
      end
    end
  }

  joins.to_a
end

#_find_objects(params, fields, search_fields) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/data_table/active_record.rb', line 5

def _find_objects params, fields, search_fields
  self.where(_where_conditions params[:ssearch], search_fields).
       includes(_discover_joins fields).tap do |query|
         if query.respond_to?(:references!)
           query.references!(_discover_joins fields)
         end
       end.
       order(_order_fields params, fields).
       paginate :page => _page(params), :per_page => _per_page(params)
end

#_order_fields(params, fields) ⇒ Object 



109
110
111
112
 
# File 'lib/data_table/active_record.rb', line 109

def _order_fields params, fields
  direction = params[:ssortdir_0] == "asc" ? "ASC" : "DESC"
  %{#{fields[params[:isortcol_0].to_i]} #{direction}}
end

#_split_where_condition(query, fields, options) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/data_table/active_record.rb', line 86

def _split_where_condition query, fields, options
  conditions = []
  parameters = []
  split_query = query.split options[:split]
  types = options[:types] || ([:string] * fields.size)

  if split_query.size == fields.size
    fields.zip(split_query).zip(types).each do |((field, query), type)|
      if type == :numeric
        conditions << "#{field} = ?"
        parameters << query.to_i
      else
        conditions << "UPPER(#{field}) LIKE ?"
        parameters << "%#{query.upcase}%"
      end
    end

    ["(" + conditions.join(" AND ") + ")", *parameters]
  else
    []
  end
end

#_where_condition(query, field) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/data_table/active_record.rb', line 60

def _where_condition query, field
  return [] if query.blank?

  if field.is_a? Array
    options = field.extract_options!

    if options[:split]
      _split_where_condition query, field, options
    elsif options[:date]
      _date_where_condition query, field.first
    else
      _where_conditions(query, field, "AND")
    end
  else
    ["UPPER(#{field}) LIKE ?", "%#{query.upcase}%"]
  end
end

#_where_conditions(query, search_fields, join_operator = "OR") ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/data_table/active_record.rb', line 37

def _where_conditions query, search_fields, join_operator = "OR"
  return if query.blank?

  all_conditions = []
  all_parameters = []

  query.split.each do |term|
    conditions = []
    parameters = []

    search_fields.each do |field|
      next if (clause = _where_condition(term, field.dup)).empty?
      conditions << clause.shift
      parameters += clause
    end

    all_conditions << conditions
    all_parameters << parameters
  end

  [all_conditions.map {|conditions| "(" + conditions.join(" #{join_operator} ") + ")" }.join(" AND "), *all_parameters.flatten]
end