Module: Discerner::Methods::Models::Search

Included in:
Search
Defined in:
lib/discerner/methods/models/search.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/discerner/methods/models/search.rb', line 5

def self.included(base)
  base.send :include, SoftDelete
  base.send :include, Warning

  # Associations
  base.send :belongs_to, :dictionary
  base.send :has_many, :search_parameters,    inverse_of: :search
  base.send :has_many, :search_combinations,  inverse_of: :search
  base.send :has_many, :combined_searches,    through: :search_combinations
  base.send :has_many, :export_parameters,    inverse_of: :search
  base.send :has_many, :search_namespaces,    inverse_of: :search

  # Validations
  base.send :validates, :dictionary, presence: { message: "for search can't be blank" }
  base.send :validate, :validate_search_parameters

  # Scopes
  base.send(:scope, :by_user, ->(username) { base.where(username: username) unless username.blank?})

  # Nested attributes
  base.send :accepts_nested_attributes_for, :search_parameters, allow_destroy: true,
    reject_if: proc { |attributes| attributes['parameter_id'].blank? && attributes['parameter'].blank? }

  base.send :accepts_nested_attributes_for, :search_combinations, allow_destroy: true,
    reject_if: proc { |attributes| attributes['combined_search_id'].blank? && attributes['combined_search'].blank? }

  # Hooks
  base.send :after_commit, :update_associations, on: :update, if: Proc.new { |record| record.previous_changes.include?('deleted_at') }
end

Instance Method Details

#conditions(force = false) ⇒ Object 



121
122
123
124
 
# File 'lib/discerner/methods/models/search.rb', line 121

def conditions(force=false)
  @conditions = self.to_conditions if @conditions.blank? || force
  @conditions
end

#disabled? ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/discerner/methods/models/search.rb', line 105

def disabled?
  return false unless persisted?
  if export_parameters.select{|ep| ep.disabled?}.any?
    warnings.add(:base, "Search uses deleted export parameters")
    return true
  end
  deleted? ||
  dictionary.deleted? ||
  search_parameters.select{|sp| sp.disabled?}.any? ||
  search_combinations.select{|sc| sc.disabled?}.any?
end

#display_name ⇒ Object 



40
41
42
 
# File 'lib/discerner/methods/models/search.rb', line 40

def display_name
  name.blank? ? "[No name specified]" : name
end

#flatten_arguments(arguments) ⇒ Object 



95
96
97
98
99
100
101
102
103
 
# File 'lib/discerner/methods/models/search.rb', line 95

def flatten_arguments(arguments)
  args = []
  arguments.each do |a|
    a.each do |b|
      args << b
    end
  end
  args
end

#initialize(*args) ⇒ Object

Instance Methods



36
37
38
 
# File 'lib/discerner/methods/models/search.rb', line 36

def initialize(*args)
  super(*args)
end

#nested_searches ⇒ Object 



59
60
61
62
 
# File 'lib/discerner/methods/models/search.rb', line 59

def nested_searches
  nested_searches = traverse || []
  nested_searches.flatten.compact
end

#parameter_categories ⇒ Object 



64
65
66
 
# File 'lib/discerner/methods/models/search.rb', line 64

def parameter_categories
  search_parameters.map{|p| p.parameter.parameter_category unless p.parameter.blank?}.uniq
end

#parameterized_name ⇒ Object 



44
45
46
 
# File 'lib/discerner/methods/models/search.rb', line 44

def parameterized_name
  display_name.parameterize.underscore
end

#searched_model?(model_name) ⇒ Boolean

Returns:

  • (Boolean) 


117
118
119
 
# File 'lib/discerner/methods/models/search.rb', line 117

def searched_model?(model_name)
  conditions.has_key?(model_name)
end

#to_conditions ⇒ Object 



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
 
# File 'lib/discerner/methods/models/search.rb', line 68

def to_conditions
  search_models = {}
  all_search_parameters = nested_searches.map { |ns| ns.search_parameters }.flatten
  all_search_parameters.concat(search_parameters).flatten!

  all_search_parameters.each do |search_parameter|
    search_models[search_parameter.parameter.search_model] = { search_parameters: [], conditions: nil } unless search_models.has_key?(search_parameter.parameter.search_model)
    search_models[search_parameter.parameter.search_model][:search_parameters] << search_parameter
  end

  search_models.each do |k,v|
    predicates = []
    arguments = []

    v[:search_parameters].each do |search_parameter|
      sql = search_parameter.to_sql unless search_parameter.search_parameter_values.empty?
      unless sql.nil?
        predicates << sql[:predicates]
        arguments << sql[:values] unless sql[:values].blank?
      end
    end

    search_models[k][:conditions] = [predicates.join(' and '), *flatten_arguments(arguments)]
  end
  search_models
end

#traverse ⇒ Object 



48
49
50
51
52
53
54
55
56
57
 
# File 'lib/discerner/methods/models/search.rb', line 48

def traverse
  return unless combined_searches.any?
  searches = []
  combined_searches.each do |s|
    searches << s
    nested_searches = s.traverse
    searches << nested_searches unless nested_searches.blank?
  end
  searches
end