Class: Symphonia::Query

Inherits:
Object
  • 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) 


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

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.



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

def active_filters
  @active_filters
end

#controller ⇒ Object (readonly)

Returns the value of attribute controller.



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

def controller
  @controller
end

#default_filters ⇒ Object

Returns the value of attribute default_filters.



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

def default_filters
  @default_filters
end

#disable_search ⇒ Object

Returns the value of attribute disable_search.



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

def disable_search
  @disable_search
end

#entity_scope ⇒ Object 



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

def entity_scope
  @entity_scope || model
end

#filters ⇒ Object 



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

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.



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

def operators
  @operators
end

#options ⇒ Object

Returns the value of attribute options.



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

def options
  @options
end

#set_filter ⇒ Object (readonly)

Returns the value of attribute set_filter.



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

def set_filter
  @set_filter
end

Instance Method Details

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



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

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

#available_filters ⇒ Object 



182
183
184
185
186
187
188
189
190
191
 
# File 'lib/symphonia/query.rb', line 182

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

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

#column_names ⇒ Object 



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

def column_names
  @column_names ||= default_column_names
end

#column_names=(names) ⇒ Object 



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

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

#columns(all = false) ⇒ Object 



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

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 



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

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 



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

def entity
  model
end

#entity_count ⇒ Object 



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

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



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

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 



178
179
180
 
# File 'lib/symphonia/query.rb', line 178

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

#render_filters(&block) ⇒ Object 



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

def render_filters(&block)
  (available_filters | filters).each(&block)
end

#scope ⇒ Object 



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

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) 


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

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

#sort_column ⇒ Object 



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

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 



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

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

#to_params(force: false) ⇒ Hash

Serialize query to params

Parameters:

  • force (FalseClass) (defaults to: false) —

    use applied filters, even that wasn’t before

Returns:

  • (Hash) 


166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/symphonia/query.rb', line 166

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

#to_partial_path ⇒ Object 



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

def to_partial_path
  'symphonia/common/query'
end