Class: Fe::Element

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/fe/element.rb

Direct Known Subclasses

Paragraph, Question, QuestionGrid, Section

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.max_label_length ⇒ Object 



224
225
226
 
# File 'app/models/fe/element.rb', line 224

def self.max_label_length
  @@max_label_length ||= Fe::Element.columns.find{ |c| c.name == "label" }.limit
end

Instance Method Details

#all_elements ⇒ Object

include nested elements



204
205
206
207
208
209
210
211
 
# File 'app/models/fe/element.rb', line 204

def all_elements
  if respond_to?(:elements)
    elements.reload
    (elements + elements.collect(&:all_elements)).flatten
  else
    []
  end
end

#conditional_match(answer_sheet) ⇒ Object 



218
219
220
221
222
 
# File 'app/models/fe/element.rb', line 218

def conditional_match(answer_sheet)
  displayed_response = display_response(answer_sheet)
  return false unless displayed_response && conditional_answer
  (displayed_response.split(',') & conditional_answer.split(',')).length > 0
end

#content(locale = nil) ⇒ Object 



59
60
61
 
# File 'app/models/fe/element.rb', line 59

def content(locale = nil)
  content_translations[locale] || self[:content]
end

#duplicate(page, parent = nil) ⇒ Object

copy an item and all it’s children



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'app/models/fe/element.rb', line 183

def duplicate(page, parent = nil)
  new_element = self.class.new(self.attributes.except('id', 'created_at', 'updated_at'))
  case parent.class.to_s
    when "Fe::QuestionGrid", "Fe::QuestionGridWithTotal"
      new_element.question_grid_id = parent.id
    when "Fe::ChoiceField"
      new_element.choice_field_id = parent.id
  end
  new_element.position = parent.elements.maximum(:position).to_i + 1 if parent
  new_element.save!(:validate => false)
  Fe::PageElement.create(:element => new_element, :page => page) unless parent

  # duplicate children
  if respond_to?(:elements) && elements.present?
    elements.each {|e| e.duplicate(page, new_element)}
  end

  new_element
end

#has_response?(answer_sheet = nil) ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
 
# File 'app/models/fe/element.rb', line 73

def has_response?(answer_sheet = nil)
  false
end

#hidden?(answer_sheet = nil, page = nil, prev_el = nil) ⇒ Boolean

use prev_el directly if it’s passed in; otherwise, pass page to previous_element to find the prev_el faster

Returns:

  • (Boolean) 


131
132
133
134
135
 
# File 'app/models/fe/element.rb', line 131

def hidden?(answer_sheet = nil, page = nil, prev_el = nil)
  @hidden ||= answer_sheet &&
    (hidden_by_choice_field?(answer_sheet) ||
     hidden_by_conditional?(answer_sheet, page, prev_el))
end

#hidden_by_choice_field?(answer_sheet) ⇒ Boolean

Returns:

  • (Boolean) 


119
120
121
122
123
 
# File 'app/models/fe/element.rb', line 119

def hidden_by_choice_field?(answer_sheet)
  choice_field.present? &&
    choice_field.is_a?(Fe::ChoiceField) &&
    choice_field.is_response_false(answer_sheet)
end

#hidden_by_conditional?(answer_sheet, page, prev_el) ⇒ Boolean

Returns:

  • (Boolean) 


112
113
114
115
116
117
 
# File 'app/models/fe/element.rb', line 112

def hidden_by_conditional?(answer_sheet, page, prev_el)
  (prev_el ||= previous_element(answer_sheet.question_sheet, page)) &&
    prev_el.is_a?(Fe::Question) &&
    prev_el.conditional == self &&
    !prev_el.conditional_match(answer_sheet)
end

#label(locale = nil) ⇒ Object

HUMANIZED_ATTRIBUTES = 

:slug => "Variable"

changed.include?(‘address1’)

def self.human_attrib_name(attr)

HUMANIZED_ATTRIBUTES[attr.to_sym] || super

end



55
56
57
 
# File 'app/models/fe/element.rb', line 55

def label(locale = nil)
  label_translations[locale] || self[:label]
end

#limit(answer_sheet = nil) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'app/models/fe/element.rb', line 77

def limit(answer_sheet = nil)
  if answer_sheet && object_name.present? && attribute_name.present?
    begin
      unless eval("answer_sheet." + self.object_name + ".nil?")
        klass = eval("answer_sheet." + self.object_name + ".class")
        column = klass.columns_hash[self.attribute_name]
        return column.limit
      end
    rescue
      nil
    end
  end
end

#page_id(page = nil) ⇒ Object 



164
165
166
167
168
169
170
 
# File 'app/models/fe/element.rb', line 164

def page_id(page = nil)
  if page
    page.id
  else
    pages.first.try(:id)
  end
end

#pages_on ⇒ Object

returns all pages this element is on, whether that be directly, through a grid, or as a choice field conditional option



68
69
70
71
 
# File 'app/models/fe/element.rb', line 68

def pages_on
  all_pages = pages.reload + [question_grid, question_grid_with_total, choice_field].compact.collect(&:pages_on)
  all_pages.flatten.uniq
end

#position(page = nil) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'app/models/fe/element.rb', line 146

def position(page = nil)
  if page
    page_elements.where(:page_id => page.id).first.try(:position)
  else
    self[:position]
  end
end

#previous_element(question_sheet, page = nil) ⇒ Object

assume each element is on a question sheet only once to make things simpler. if not, just take the first one



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'app/models/fe/element.rb', line 92

def previous_element(question_sheet, page = nil)
  unless page
    page_element = page_elements.joins(page: :question_sheet).where("#{Fe::QuestionSheet.table_name}.id" => question_sheet.id).first
    return unless page_element
    page = page_element.page
  end

  index = page.all_element_ids_arr.index(self.id)
  unless index
    # this can happen for yesno options, since they're rendered as elements but aren't on the page or in a grid
    # but just in case self is an element on the page and the element_ids got out of sync, rebuild the all_element_ids
    # and try again
    page.rebuild_all_element_ids
    index = page.all_element_ids_arr.index(self.id)
  end
  if index && index > 0 && prev_el_id = page.all_element_ids_arr[index-1]
    return Fe::Element.find(prev_el_id)
  end
end

#ptemplate ⇒ Object

by default the partial for an element matches the class name (override as necessary)



178
179
180
 
# File 'app/models/fe/element.rb', line 178

def ptemplate
  self.class.to_s.underscore
end

#question? ⇒ Boolean

Returns:

  • (Boolean) 


172
173
174
 
# File 'app/models/fe/element.rb', line 172

def question?
  self.kind_of?(Question)
end

#required?(answer_sheet = nil, page = nil, prev_el = nil) ⇒ Boolean

use prev_el directly if it’s passed in; otherwise, pass page to previous_element to find the prev_el faster

Returns:

  • (Boolean) 


138
139
140
141
142
143
144
 
# File 'app/models/fe/element.rb', line 138

def required?(answer_sheet = nil, page = nil, prev_el = nil)
  if hidden?(answer_sheet, page, prev_el)
    return false
  else
    required == true
  end
end

#reuseable? ⇒ Boolean

Returns:

  • (Boolean) 


213
214
215
216
 
# File 'app/models/fe/element.rb', line 213

def reuseable?
  return false if Fe.never_reuse_elements
  (self.is_a?(Fe::Question) || self.is_a?(Fe::QuestionGrid) || self.is_a?(Fe::QuestionGridWithTotal))
end

#set_conditional_element ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'app/models/fe/element.rb', line 228

def set_conditional_element
  case conditional_type
  when "Fe::Element"
    pages_on.each do |page|

      if index = page.all_element_ids_arr.index(self.id)
        self.conditional_id = page.all_element_ids_arr[index+1]
      else 
        self.conditional_id = nil
      end
    end
  when ""
    # keep conditional_type nil instead of empty to be consistent
    self.conditional_type = nil
  end
end

#set_position(position, page = nil) ⇒ Object 



154
155
156
157
158
159
160
161
162
 
# File 'app/models/fe/element.rb', line 154

def set_position(position, page = nil)
  if page
    pe = page_elements.where(:page_id => page.id).first
    pe.update_attribute(:position, position) if pe
  else
    self[:position] = position
  end
  position
end

#tooltip(locale = nil) ⇒ Object 



63
64
65
 
# File 'app/models/fe/element.rb', line 63

def tooltip(locale = nil)
  tip_translations[locale] || self[:tooltip]
end

#update_any_previous_conditional_elements ⇒ Object 



245
246
247
248
249
250
251
252
253
254
255
 
# File 'app/models/fe/element.rb', line 245

def update_any_previous_conditional_elements
  pages_on.each do |page|
    index = page.all_element_ids_arr.index(self.id)
    if index && index > 0
      prev_el = Fe::Element.find(page.all_element_ids_arr[index-1])
      if prev_el.conditional_type == "Fe::Element"
        prev_el.update_column(:conditional_id, id)
      end
    end
  end
end

#update_page_all_element_ids ⇒ Object 



257
258
259
260
261
262
263
 
# File 'app/models/fe/element.rb', line 257

def update_page_all_element_ids
  [question_grid, question_grid_with_total].compact.each do |field|
    field.update_page_all_element_ids
  end

  pages.reload.each do |p| p.rebuild_all_element_ids end
end

#visible?(answer_sheet = nil, page = nil, prev_el = nil) ⇒ Boolean

use prev_el directly if it’s passed in; otherwise, pass page to previous_element to find the prev_el faster

Returns:

  • (Boolean) 


126
127
128
 
# File 'app/models/fe/element.rb', line 126

def visible?(answer_sheet = nil, page = nil, prev_el = nil)
  !hidden?(answer_sheet, page, prev_el)
end