Module: TableOnSteroids::TableConcern

Extended by:
ActiveSupport::Concern
Defined in:
app/controllers/concerns/table_on_steroids/table_concern.rb

Instance Method Summary collapse

Instance Method Details

#all_column_search(objects, columns_on_steroid, query, table_on_steroids = nil) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 125

def all_column_search(objects, columns_on_steroid, query, table_on_steroids = nil)
  global_active_record_search_key = table_on_steroids&.dig(:global_active_record_search_key) || :id
  global_array_search_key_index = table_on_steroids&.dig(:global_array_search_key_index) || 0
  global_search_key = (objects && objects[0].is_a?(Array) ? global_array_search_key_index : global_active_record_search_key)
  global_search_key_params = {}
  matched_object_keys = []

  %i[activerecord array].each do |t|
    columns_on_steroid.each do |_key, value|
      next unless value[t].present? && ((value[t][:search_lambda].present? && !%w[date integer].include?(value[:datatype])) || value[t][:global_search_lambda].present?)

      objects_returned = if value[t][:global_search_lambda].present?
                           value[t][:global_search_lambda].call(objects, query)
                         else
                           value[t][:search_lambda].call(objects, query)
                         end
      objects_returned&.each { |o| matched_object_keys << o[global_search_key] }
    end
  end

  if objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation)
    global_search_key_params[global_active_record_search_key] = matched_object_keys.uniq
    objects = objects.where(global_search_key_params)
  elsif objects.is_a?(Array)
    objects = objects.select { |o| o if matched_object_keys.uniq.include?(o[global_search_key]) }
  end
end

#filter_and_order(objects, columns_on_steroid, global_search = nil, include_counts = false, all_pages = false, table_on_steroids = nil, rows_to_display = nil) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 42

def filter_and_order(objects, columns_on_steroid, global_search = nil, include_counts = false, all_pages = false, table_on_steroids = nil, rows_to_display = nil)
  limit = rows_to_display || OBJECTS_PER_PAGE

  # execute the global search if you have one
  if params[:search].present?
    objects = global_search.call(objects, params[:search]) if global_search
    objects = all_column_search(objects, columns_on_steroid, params[:search], table_on_steroids) unless global_search
  end

  %i[activerecord array].each do |t|
    # column search
    objects = objects_where(objects, columns_on_steroid, t)

    filter_columns = columns_on_steroid.map{|k,v| k if v.dig(t,:filter_lambda) }.compact
    filter_columns.each do |k|
      filter_value = (params[:filters] && params[:filters][k]) || params[k]
      if(!filter_value.blank?)
        objects = columns_on_steroid[k][t][:filter_lambda].call(objects, filter_value)
      end
    end

    #order
    if params&.dig(:knowledge,:order) && (object_order = columns_on_steroid[params[:knowledge][:order]]).present?
      if(object_order[t] && object_order[t][:order_lambda])
        direction = (params&.dig(:knowledge,:ascending).to_s == 'true') ? 'asc' : 'desc'
        objects = objects.reorder(nil) if(objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation))
        objects = object_order[t][:order_lambda].call(objects, direction)
      end
    elsif object_order = columns_on_steroid[table_on_steroids&.dig(:default_order_column)]
      if(object_order[t] && object_order[t][:order_lambda])
        direction = object_order[t][:default_order_direction] || 'asc'
        objects = objects.reorder(nil) if(objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation))
        objects = object_order[t][:order_lambda].call(objects, direction)
      end
    elsif (object_order = columns_on_steroid.select { |_c, v| v[t] && v[t][:default_order] }.first&.last).present?
      if object_order[t] && object_order[t][:order_lambda]
        objects = objects.reorder(nil) if objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation)
        objects = object_order[t][:order_lambda].call(objects)
      end
    elsif objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation)
      # objects = objects.order('created_at desc')
    end
  end

  # pagination
  return (include_counts ? [objects, 1, objects.count] : objects) if all_pages

  # GO to specific object page
  page = get_page(objects, params, table_on_steroids, limit)

  if objects.is_a?(ActiveRecord::Base) || objects.is_a?(ActiveRecord::Relation)
    objects = objects.page(page).per(limit)
    total_pages = objects.total_pages
    total_count = objects.total_count
  else
    objects = Kaminari.paginate_array(objects).page(page).per(limit)
    total_pages = objects.total_pages
    total_count = objects.total_count
  end
  include_counts ? [objects, total_pages, total_count, page] : objects
end

#get_page(objects, params, table_on_steroids, limit) ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 230

def get_page(objects, params, table_on_steroids, limit)
  active_record_object_fetch_opts = table_on_steroids&.dig(:active_record_object_fetch_opts)
  key_lambda = table_on_steroids&.dig(:key_lambda)
  return params[:page] unless active_record_object_fetch_opts && key_lambda

  object = objects.where(active_record_object_fetch_opts).first
  return params[:page] unless object

  index = objects.index { |o| key_lambda.call(o) == key_lambda.call(object) }
  index ? index / limit + 1 : params[:page]
end

#object_where_integer(integer, operator, value) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 189

def object_where_integer(integer, operator, value)
  case operator
  when '<', '>='
    integer.to_f < value.to_f
  when '='
    integer.to_f == value.to_f
  when '>'
    integer.to_f > value.to_f
  end
end

#objects_where(objects, columns_on_steroid, t) ⇒ Object 



153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 153

def objects_where(objects, columns_on_steroid, t)
  columns_on_steroid.select do |_c, v|
    v[t] && v[t][:search_lambda].present?
  end .each do |c, v|
    if params['search_operator_' + c] # (v[:datatype].present? && ['date','integer'].include?(v[:datatype]))
      objects = v[t][:search_lambda].call(objects, params['search_' + c], params['search_operator_' + c]) if params['search_' + c] && !params['search_' + c].blank?
    else
      objects = v[t][:search_lambda].call(objects, params['search_' + c]) if params['search_' + c] && !params['search_' + c].blank?
    end
  end
  objects
end

#objects_where_date(objects, column, value, operator) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 166

def objects_where_date(objects, column, value, operator)
  case operator
  when '<', '>='
    objects.where((column + ' ' + operator + ' ?'), (value + ' 00:00:00'))
  when '>', '<='
    objects.where((column + ' ' + operator + ' ?'), (value + ' 23:59:59'))
  when '='
    objects.where((column + ' between ? and ?'), (value + ' 00:00:00'), (value + ' 23:59:59'))
  end
end

#objects_where_or(objects, columns_on_steroid) ⇒ Object

save for later



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 201

def objects_where_or(objects, columns_on_steroid)
  where_sql = ''
  values = []

  # search all columns
  unless query.blank?
    where_sql += columns_on_steroid.select do |_c, v|
                   v[:or_where_sql].present?
                 end .map do |_c, v|
      v[:or_where_sql].map do |w|
        w[:where]
      end .join(' or ')
    end .join(' or ')

    columns_on_steroid.select do |_c, v|
      v[:or_where_sql].present?
    end .map do |_c, v|
      v[:or_where_sql].each do |w|
        values << (w[:value] || ('%' + query + '%'))
      end
    end

    where_sql = ('(' + where_sql + ')') unless where_sql.blank?

    objects = objects.where(where_sql, *values)
  end
  objects
end

#objects_where_ruby_date(object, column, value, operator) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 177

def objects_where_ruby_date(object, column, value, operator)
  value = Date.strptime(value, '%m/%d/%Y').midnight
  case operator
  when '<'
    return object.send(column) < value
  when '>'
    return object.send(column) > value + 1.days - 1.seconds
  when '='
    return ((object.send(column) > value) && (object.send(column) < (value + 1.days - 1.seconds)))
  end
end

#table_csv(objects, columns_on_steroid, client = false) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'app/controllers/concerns/table_on_steroids/table_concern.rb', line 104

def table_csv(objects, columns_on_steroid, client = false)
  titles = []
  value_lambda = :download_value_lambda
  label = :download_label
  if(client)
    value_lambda = :client_download_value_lambda
    label = :client_download_label
  end
  csvs = CSV.generate do |csv|
    columns_on_steroid.select { |_c, v| v[value_lambda].present? }.each { |_c, v| (v[label].present? ? titles.push(*v[label]) : titles << v[:label]) }
    csv << titles
    objects.each do |o|
      vals = []
      columns_on_steroid.select { |_c, v| v[value_lambda].present? }.each do |_c, v|
        vals.push(*v[value_lambda].call(o))
      end
      csv << vals
    end
  end
end