Class: Symphonia::Query

Inherits:
Object show all
Defined in:
lib/symphonia/query.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(c = nil, sort: "", filters: {}, columns: nil, **options) ⇒ Query

Returns a new instance of Query.

Parameters:

  • sort (nil, String) (defaults to: "") —

    column_name:asc|desc

  • filters (Hash) (defaults to: {})
  • columns (nil, Array) (defaults to: nil) 


18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/symphonia/query.rb', line 18

def initialize(c = nil, sort: "", filters: {}, columns: nil, **options)
  if c
    ActiveSupport::Deprecation.warn("initialize allow only hash. #{c} - update your controller:")
    #
    # model.query.new sort: "default sort", filters: {default: filter}, columns: [columns, names]
    # @query.from_params params
    #
  end
  ActiveSupport::Deprecation.warn("default_order is deprecated, use just `sort`") if options[:default_order]
  @active_filters = {}
  @default_sort = sort
  @default_filters = filters
  @default_column_names = columns
  @options = options
end

Instance Attribute Details

#active_filters ⇒ Object

Returns the value of attribute active_filters.



10
11
12
 
# File 'lib/symphonia/query.rb', line 10

def active_filters
  @active_filters
end

#controller ⇒ Object (readonly)

Returns the value of attribute controller.



8
9
10
 
# File 'lib/symphonia/query.rb', line 8

def controller
  @controller
end

#default_filters ⇒ Object

Returns the value of attribute default_filters.



10
11
12
 
# File 'lib/symphonia/query.rb', line 10

def default_filters
  @default_filters
end

#disable_search ⇒ Object

Returns the value of attribute disable_search.



10
11
12
 
# File 'lib/symphonia/query.rb', line 10

def disable_search
  @disable_search
end

#entity_scope ⇒ Object 



117
118
119
 
# File 'lib/symphonia/query.rb', line 117

def entity_scope
  @entity_scope || model
end

#filters ⇒ Object 



121
122
123
124
125
126
127
128
129
130
 
# File 'lib/symphonia/query.rb', line 121

def filters
  setup_filters(default_filters) unless @set_filter
  @filters ||= available_filters.select do |filter|
    if (q = active_filters[filter.name])
      operators && (filter.operator = operators[filter.name])
      filter.value = q
    end
  end
  @filters
end

#operators ⇒ Object

Returns the value of attribute operators.



11
12
13
 
# File 'lib/symphonia/query.rb', line 11

def operators
  @operators
end

#options ⇒ Object

Returns the value of attribute options.



10
11
12
 
# File 'lib/symphonia/query.rb', line 10

def options
  @options
end

#set_filter ⇒ Object (readonly)

Returns the value of attribute set_filter.



8
9
10
 
# File 'lib/symphonia/query.rb', line 8

def set_filter
  @set_filter
end

Instance Method Details

#activate_filter(name, value) ⇒ Object Also known as: add_filter 



87
88
89
 
# File 'lib/symphonia/query.rb', line 87

def activate_filter(name, value)
  @active_filters[name] ||= value.downcase
end

#available_filters ⇒ Object 



179
180
181
182
183
184
185
186
187
188
 
# File 'lib/symphonia/query.rb', line 179

def available_filters
  self.active_filters ||= {}
  self.operators ||= {}

  if @available_filters.nil?
    @available_filters = []
    register_filters
  end
  @available_filters
end

#column_names ⇒ Object 



101
102
103
 
# File 'lib/symphonia/query.rb', line 101

def column_names
  @column_names ||= default_column_names
end

#column_names=(names) ⇒ Object 



97
98
99
 
# File 'lib/symphonia/query.rb', line 97

def column_names=(names)
  @column_names = (names.is_a?(Array) ? names : names.to_s.split('|')).map(&:to_sym)
end

#columns(all = false) ⇒ Object 



105
106
107
108
109
 
# File 'lib/symphonia/query.rb', line 105

def columns(all = false)
  return available_columns.values if all || Array(column_names).blank?

  @columns ||= column_names.map { |c| available_columns[c] }.compact
end

#entities ⇒ Object 



145
146
147
148
149
150
 
# File 'lib/symphonia/query.rb', line 145

def entities
  return @entities unless @entities.nil?

  order = sort_column.order
  @entities = scope.order(order.is_a?(String) && Arel.sql(order) || order)
end

#entity ⇒ Object 



93
94
95
 
# File 'lib/symphonia/query.rb', line 93

def entity
  model
end

#entity_count ⇒ Object 



152
153
154
 
# File 'lib/symphonia/query.rb', line 152

def entity_count
  entities.reorder(nil).count
end

#from_params(params) ⇒ Object

Parameters:

  • params (Hash)

Options Hash (params):

  • :sort (String) —

    name of column, also can be name:direction

  • :direction (String) —

    ASC or DESC

  • :set_filter (Boolean) —

    if ‘true` apply filters



38
39
40
41
42
43
44
 
# File 'lib/symphonia/query.rb', line 38

def from_params(params)
  @sort_col, @sort_dir = params[:sort]&.split(":")
  @sort_dir ||= params[:direction]
  self.entity_scope = entity.like(@q) if (@q = params[:q].presence)
  setup_filters(params) if (@set_filter = params[:set_filter].to_boolean)
  setup_columns(params)
end

#inspect ⇒ Object 



174
175
176
 
# File 'lib/symphonia/query.rb', line 174

def inspect
  "#<#{self.class.name} set_filter=#{@set_filter} >"
end

#render_filters ⇒ Object 



111
112
113
114
115
 
# File 'lib/symphonia/query.rb', line 111

def render_filters
  (available_filters | filters).each do |filter|
    yield filter
  end
end

#scope ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/symphonia/query.rb', line 132

def scope
  opts = columns.each_with_object(includes: [], preload: [], joins: []) do |var, mem|
    mem[:includes].concat var.includes
    mem[:preload].concat var.preload
    mem[:joins].concat var.joins
  end
  x = entity_scope.includes(opts[:includes].uniq).preload(opts[:preload].uniq).joins(opts[:joins].uniq)
  filters.each do |filter|
    x = filter.apply(x)
  end
  x
end

#search? ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/symphonia/query.rb', line 83

def search?
  disable_search.nil? && model.respond_to?(:like)
end

#sort_column ⇒ Object 



72
73
74
75
76
77
78
79
80
81
 
# File 'lib/symphonia/query.rb', line 72

def sort_column
  c, d = @default_sort.split(':')
  c ||= available_columns[:name]&.name
  @sort_table ||= SortableTable::SortTable.new(available_columns.collect { |_n, c| c.sort_definition }.compact,
                                               default_column: c&.to_sym,
                                               default_direction: d&.to_sym)
  @sort_column ||= @sort_table.sort_column(@sort_col, @sort_dir)
rescue StandardError
  raise "Incorrect default column: '#{options[:default_sort]}'"
end

#summarize_columns ⇒ Object 



156
157
158
 
# File 'lib/symphonia/query.rb', line 156

def summarize_columns
  columns.select(&:summarize?)
end

#to_params(force = false) ⇒ Object 



164
165
166
167
168
169
170
171
172
 
# File 'lib/symphonia/query.rb', line 164

def to_params(force = false)
  if @q
    { q: @q }
  elsif @set_filter || force
    filters.each_with_object(set_filter: 1) { |var, mem| f, v = var; mem[f.send(:form_field_name).to_sym] = v; }
  else
    {}
  end
end

#to_partial_path ⇒ Object 



160
161
162
 
# File 'lib/symphonia/query.rb', line 160

def to_partial_path
  'symphonia/common/query'
end