fe 1.0.0 → 2.0.0

data/app/models/fe/email_address.rb

@@ -1,7 +1,7 @@
 require 'validates_email_format_of'
-class Fe::EmailAddress < ActiveRecord::Base
+class Fe::EmailAddress < ApplicationRecord
   belongs_to :person
-  validates :email, :email_format => { :message => "doesn't look right." }
+  validates :email, email_format: { message: "doesn't look right." }
 
   self.table_name = "email_addresses"
 end

data/app/models/fe/email_template.rb

@@ -1,5 +1,5 @@
 module Fe
-  class EmailTemplate < ActiveRecord::Base
+  class EmailTemplate < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
     validates_presence_of :name

data/app/models/fe/page.rb

@@ -1,8 +1,10 @@
 require 'acts_as_list'
 module Fe
-  class Page < ActiveRecord::Base
+  class Page < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
+    attr_accessor :old_id
+
     belongs_to :question_sheet
 
     has_many :page_elements, -> { order(:position) },
@@ -23,24 +25,26 @@ module Fe
              through: :page_elements,
              source: :element
 
-    # has_many :conditions, :class_name => "Condition", :foreign_key => "toggle_page_id",   # conditions associated with page as a whole
-    #         conditions: 'toggle_id is NULL', :dependent => :nullify
+    # has_many :conditions, class_name: "Condition", foreign_key: "toggle_page_id",   # conditions associated with page as a whole
+    #         conditions: 'toggle_id is NULL', dependent: :nullify
 
-    acts_as_list :column => :number, :scope => :question_sheet_id
+    acts_as_list column: :number, scope: :question_sheet_id
 
-    scope :visible, -> { where(:hidden => false) }
+    scope :visible, -> { where(hidden: false) }
 
     # callbacks
-    before_validation :set_default_label, :on => :create    # Page x
+    before_validation :set_default_label, on: :create    # Page x
 
     # validation
     validates_presence_of :label, :number
-    validates_length_of :label, :maximum => 100, :allow_nil => true
+    validates_length_of :label, maximum: 100, allow_nil: true
 
-    # validates_uniqueness_of :number, :scope => :question_sheet_id
+    # validates_uniqueness_of :number, scope: :question_sheet_id
 
-    validates_numericality_of :number, :only_integer => true
+    validates_numericality_of :number, only_integer: true
 
+    # NOTE: You may need config.active_record.yaml_column_permitted_classes = [Hash, ActiveSupport::HashWithIndifferentAccess]
+    # in config/application.rb or you may get Psych::DisallowedClass trying to use label_translations
     serialize :label_translations, Hash
 
     # a page is disabled if there is a condition, and that condition evaluates to false
@@ -54,6 +58,16 @@ module Fe
     #   false
     # end
 
+    def conditionally_visible?
+      question_sheet&.all_elements&.where(conditional_type: 'Fe::Page', conditional_id: self)&.any?
+    end
+
+    # any page that's conditionally visible should not use cache, there are race conditions otherwise
+    # that happen when the conditional value is set and the now visible page loaded in ajax
+    def no_cache
+      conditionally_visible? || self[:no_cache]
+    end
+
     def label(locale = nil)
       label_translations[locale] || self[:label]
     end
@@ -75,7 +89,7 @@ module Fe
     def all_elements
       ids = all_element_ids_arr
       order = ids.collect{ |id| "id=#{id} DESC" }.join(', ')
-      ids.present? ? Element.where(id: ids).order(order) : Element.where("1 = 0")
+      ids.present? ? Element.where(id: ids).order(Arel.sql(order)) : Element.where("1 = 0")
     end
 
     def all_element_ids
@@ -94,33 +108,46 @@ module Fe
     def copy_to(question_sheet)
       new_page = Fe::Page.new(self.attributes.merge(id: nil))
       new_page.question_sheet_id = question_sheet.id
-      new_page.save(:validate => false)
+      new_page.save(validate: false)
       self.elements.each do |element|
         if !question_sheet.archived? && element.reuseable?
-          Fe::PageElement.create(:element => element, :page => new_page)
+          Fe::PageElement.create(element: element, page: new_page)
         else
           element.duplicate(new_page)
         end
       end
       new_page.rebuild_all_element_ids
+      new_page
     end
 
     def hidden?(answer_sheet)
-      return false unless question_sheet.all_elements.where(conditional_type: 'Fe::Page', conditional_id: self).any?
+      return true if hidden
+
+      @hidden_cache ||= {}
+      return @hidden_cache[answer_sheet] if !@hidden_cache[answer_sheet].nil?
+
+      unless conditionally_visible?
+        @hidden_cache[answer_sheet] = false
+        return false
+      end
 
       # if any of the conditional questions matches, it's visible
-      !question_sheet.all_elements.where(conditional_type: 'Fe::Page', conditional_id: self).any?{ |e|
-        e.conditional_match(answer_sheet)
+      r = !question_sheet.all_elements.where(conditional_type: 'Fe::Page', conditional_id: self).any?{ |e|
+        e.visible?(answer_sheet) && e.conditional_match(answer_sheet)
       }
+      @hidden_cache[answer_sheet] = r
+      return r
+    end
+
+    def clear_hidden_cache
+      @hidden_cache = nil
     end
 
     def complete?(answer_sheet)
       return true if hidden?(answer_sheet)
-      prev_el = nil
+
       all_elements.all? {|e|
-        complete = !e.required?(answer_sheet, self, prev_el) || e.has_response?(answer_sheet)
-        prev_el = e
-        complete
+        e.hidden?(answer_sheet, self) || !e.required?(answer_sheet, self) || e.has_response?(answer_sheet)
       }
     end
 
@@ -128,6 +155,54 @@ module Fe
       all_questions.any? {|e| e.has_response?(answer_sheet)}
     end
 
+    def all_hidden_elements(answer_sheet)
+      @all_hidden_elements ||= {}
+      @all_hidden_elements[answer_sheet.cache_key] ||= build_all_hidden_elements(answer_sheet)
+    end
+
+    def build_all_hidden_elements(answer_sheet)
+      @all_hidden_elements ||= {}
+      @all_hidden_elements[answer_sheet.cache_key] = []
+      all_elements.each do |e|
+        next if @all_hidden_elements[answer_sheet.cache_key].include?(e)
+        if e.hidden_by_choice_field?(answer_sheet) || e.hidden_by_conditional?(answer_sheet, self)
+          @all_hidden_elements[answer_sheet.cache_key] += ([e] + e.all_elements)
+          @all_hidden_elements[answer_sheet.cache_key].uniq!
+        end
+      end
+      @all_hidden_elements[answer_sheet.cache_key]
+    end
+
+    def clear_all_hidden_elements
+      @all_hidden_elements = nil
+    end
+
+    def export_hash
+      base_attributes = self.attributes.to_hash
+      base_attributes[:elements] = elements.collect(&:export_hash)
+      base_attributes.delete(:id)
+      base_attributes[:question_sheet_id] = :question_sheet_id
+      base_attributes
+    end
+
+    def export_to_yaml
+      export_hash.to_yaml
+    end
+
+    def self.create_from_import(page_data, question_sheet)
+      elements = page_data.delete(:elements)
+      page_data.delete(:all_element_ids) # this can get build again
+      page_data[:old_id] = page_data.delete('id')
+      page_data[:question_sheet_id] = question_sheet.id
+      puts("Import page from data #{page_data}")
+      page = Fe::Page.create!(page_data)
+      elements.each do |el|
+        page.elements << Fe::Element.create_from_import(el, page, question_sheet)
+      end
+      page.rebuild_all_element_ids
+      page
+    end
+
     private
 
     # next unused label with "Page" prefix

data/app/models/fe/page_element.rb

@@ -1,8 +1,8 @@
 require 'acts_as_list'
 module Fe
-  class PageElement < ActiveRecord::Base
+  class PageElement < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
-    acts_as_list :scope => :page_id
+    acts_as_list scope: :page_id
     belongs_to :page, touch: true
     belongs_to :element
 

data/app/models/fe/paragraph.rb

@@ -5,6 +5,6 @@
 # :content      - instructions, agreements, etc. to display
 module Fe
   class Paragraph < Element
-    validates_presence_of :content, :on => :update
+    validates_presence_of :content, on: :update
   end
 end

data/app/models/fe/person.rb

@@ -1,6 +1,6 @@
 module Fe
-  class Person < ActiveRecord::Base
-    belongs_to :user, :foreign_key => "fk_ssmUserId" # TODO need to migrate person columns to be more rails-like
+  class Person < ApplicationRecord
+    belongs_to :user, optional: true, foreign_key: "fk_ssmUserId" # TODO need to migrate person columns to be more rails-like
     has_many   :email_addresses, class_name: '::EmailAddress', dependent: :destroy
     has_many   :phone_numbers, class_name: '::PhoneNumber', dependent: :destroy
     has_one    :current_address, -> { where("address_type = 'current'") }, class_name: '::Fe::Address', dependent: :destroy
@@ -17,15 +17,15 @@ module Fe
     end
 
     def create_emergency_address
-      Address.create(:person_id => self.id, :address_type => 'emergency1')
+      Address.create(person_id: self.id, address_type: 'emergency1')
     end
 
     def create_current_address
-      Address.create(:person_id => self.id, :address_type => 'current')
+      Address.create(person_id: self.id, address_type: 'current')
     end
 
     def create_permanent_address
-      Address.create(:person_id => self.id, :address_type => 'permanent')
+      Address.create(person_id: self.id, address_type: 'permanent')
     end
 
     def name

data/app/models/fe/phone_number.rb

@@ -1,4 +1,4 @@
-class Fe::PhoneNumber < ActiveRecord::Base
+class Fe::PhoneNumber < ApplicationRecord
   belongs_to :person
 
   self.table_name = "phone_numbers"

data/app/models/fe/question.rb

@@ -12,34 +12,40 @@ module Fe
   class Question < Element
     include ActionView::RecordIdentifier # dom_id
     has_many :conditions,
-             :class_name => "Condition",
-             :foreign_key => "toggle_id",
-             :dependent => :nullify
+             class_name: "Condition",
+             foreign_key: "toggle_id",
+             dependent: :nullify
 
     has_many :dependents,
-             :class_name => "Condition",
-             :foreign_key => "trigger_id",
-             :dependent => :nullify
+             class_name: "Condition",
+             foreign_key: "trigger_id",
+             dependent: :nullify
 
     has_many :sheet_answers,
-             :class_name => "Answer",
-             :foreign_key => "question_id",
-             :dependent => :destroy
+             class_name: "Answer",
+             foreign_key: "question_id",
+             dependent: :destroy
 
     belongs_to :related_question_sheet,
-               :class_name => "QuestionSheet",
-               :foreign_key => "related_question_sheet_id"
+               optional: true,
+               class_name: "QuestionSheet",
+               foreign_key: "related_question_sheet_id"
 
-    # validates_inclusion_of :required, :in => [false, true]
+    # validates_inclusion_of :required, in: [false, true]
 
-    validates_format_of :slug, :with => /\A[a-z_][a-z0-9_]*\z/,
-                        :allow_nil => true, :if => Proc.new { |q| !q.slug.blank? },
-                        :message => 'may only contain lowercase letters, digits and underscores; and cannot begin with a digit.' # enforcing lowercase because javascript is case-sensitive
-    validates_length_of :slug, :in => 4..36,
-                        :allow_nil => true, :if => Proc.new { |q| !q.slug.blank? }
-    validates_uniqueness_of :slug,
-                            :allow_nil => true, :if => Proc.new { |q| !q.slug.blank? },
-                            :message => 'must be unique.'
+    validates_format_of :slug, with: /\A[a-z_][a-z0-9_]*\z/,
+                        allow_nil: true, if: Proc.new { |q| !q.slug.blank? },
+                        message: 'may only contain lowercase letters, digits and underscores; and cannot begin with a digit.' # enforcing lowercase because javascript is case-sensitive
+    validates_length_of :slug, in: 4..128,
+                        allow_nil: true, if: Proc.new { |q| !q.slug.blank? }
+
+    validates_each :slug, allow_nil: true, allow_blank: true do |record, attr, value|
+      record.pages_on.collect(&:question_sheet).uniq.each do |qs|
+        if qs.all_elements.where(slug: record.slug).where("id != ?", record.id).any?
+          record.errors.add(attr, "must be unique (within the question sheet)")
+        end
+      end
+    end
 
     # a question has one response per AnswerSheet (that is, an instance of a user filling out the question)
     # generally the response is a single answer
@@ -66,9 +72,9 @@ module Fe
     #     expression = new_conditions[i]["expression"]
     #     trigger_id = new_conditions[i]["trigger_id"].to_i
     #     unless expression.blank? || !page.questions.collect(&:id).include?(trigger_id) || conditions.collect(&:trigger_id).include?(trigger_id)
-    #       conditions.create(:question_sheet_id => question_sheet_id, :trigger_id => trigger_id,
-    #                         :expression => expression, :toggle_page_id => page_id,
-    #                         :toggle_id => self.id)
+    #       conditions.create(question_sheet_id: question_sheet_id, trigger_id: trigger_id,
+    #                         expression: expression, toggle_page_id: page_id,
+    #                         toggle_id: self.id)
     #     end
     #   end
     # end
@@ -78,7 +84,9 @@ module Fe
       true
     end
 
-    def locked?(params, answer_sheet, presenter)
+    # NOTE: current_person is passed in for the benefit of enclosing apps that override locked?
+    # and need to lock an element depending on who the current person is
+    def locked?(params, answer_sheet, presenter, current_person)
       return true unless params['action'] == 'edit'
       if self.object_name == 'person.current_address' && ['address1','address2','city','zip','email','state','country'].include?(self.attribute_name)
         # Billing Address
@@ -90,13 +98,14 @@ module Fe
         # Relationship & Country & Email Address
         return false
       else
-        return answer_sheet.frozen? && !presenter.reference?
+        return answer_sheet.frozen? && !presenter.reference? &&
+          !@answer_sheet.try(:reference?)
       end
     end
 
     # css class names for javascript-based validation
-    def validation_class(answer_sheet = nil)
-      if required?(answer_sheet)
+    def validation_class(answer_sheet = nil, page = nil)
+      if required?(answer_sheet, page)
         ' required '
       else
         ''
@@ -147,8 +156,9 @@ module Fe
           [eval("obj." + attribute_name)]
         end
       else
-        #answer_sheet.answers_by_question[id] || []
-        Fe::Answer.where(:answer_sheet_id => answer_sheet.id, :question_id => self.id).to_a
+        answers = sheet_answers.where(answer_sheet: answer_sheet)
+        answers = answers.where("value IS NOT NULL AND value != ''")
+        answers.to_a
       end
     end
 
@@ -180,7 +190,8 @@ module Fe
         #   raise object_name.inspect + ' == ' + attribute_name.inspect
         # end
       else
-        @answers ||= []
+        @answers = sheet_answers.where(answer_sheet_id: answer_sheet.id).to_a
+        @answer_sheet_answers_are_for = answer_sheet
         @mark_for_destroy ||= []
         # go through existing answers (in reverse order, as we delete)
         (@answers.length - 1).downto(0) do |index|
@@ -195,7 +206,7 @@ module Fe
         # insert any new answers
         for value in values
           if @mark_for_destroy.empty?
-            answer = Fe::Answer.new(:question_id => self.id)
+            answer = Fe::Answer.new(question_id: self.id)
           else
             # re-use marked answers (an update vs. a delete+insert)
             answer = @mark_for_destroy.pop
@@ -206,13 +217,26 @@ module Fe
       end
     end
 
+    def check_answer_sheet_matches_set_response_answer_sheet(answer_sheet)
+      if @answer_sheet_answers_are_for && @answer_sheet_answers_are_for != answer_sheet
+        fail("Trying to save answers to a different answer sheet than the one given in set_response")
+      end
+    end
+
     def save_file(answer_sheet, file)
+      check_answer_sheet_matches_set_response_answer_sheet(answer_sheet)
       @answers.collect(&:destroy) if @answers
-      Fe::Answer.create!(:question_id => self.id, :answer_sheet_id => answer_sheet.id, :attachment => file)
+      Fe::Answer.create!(question_id: self.id, answer_sheet_id: answer_sheet.id, attachment: file)
+    end
+
+    def delete_file(answer_sheet, answer)
+      check_answer_sheet_matches_set_response_answer_sheet(answer_sheet)
+      answer.destroy
     end
 
     # save this question's @answers to database
     def save_response(answer_sheet)
+      check_answer_sheet_matches_set_response_answer_sheet(answer_sheet)
       unless @answers.nil?
         for answer in @answers
           if answer.is_a?(Fe::Answer)
@@ -229,19 +253,19 @@ module Fe
         end
         @mark_for_destroy.clear
       end
+
+      # clear hidden elements cache on page since this answer might modify which elements are hidden
+      pages_on.each do |p| p.clear_all_hidden_elements; end
+
     rescue TypeError
       raise answer.inspect
     end
 
     # has any sort of non-empty response?
     def has_response?(answer_sheet = nil)
-      if answer_sheet.present?
-        answers = responses(answer_sheet)
-      else
-        answers = Fe::Answer.where(:question_id => self.id)
-      end
+      answers = answer_sheet.present? ? responses(answer_sheet) : sheet_answers
       return false if answers.length == 0
-      answers.each do |answer|   # loop through Answers
+      answers.each do |answer|
         value = answer.is_a?(Fe::Answer) ? answer.value : answer
         return true if (value.is_a?(FalseClass) && value === false) || value.present?
       end

data/app/models/fe/question_grid.rb

@@ -8,9 +8,9 @@ module Fe
   class QuestionGrid < Element
 
     has_many :elements, -> { order('position asc, id asc') },
-             :class_name => "Element",
-             :foreign_key => "question_grid_id",
-             :dependent => :nullify
+             class_name: "Element",
+             foreign_key: "question_grid_id",
+             dependent: :nullify
 
     def num_cols
       num = cols.to_s.split(';').length
@@ -21,5 +21,17 @@ module Fe
     def has_response?(answer_sheet = nil)
       elements.any? {|e| e.has_response?(answer_sheet)}
     end
+
+    def export_hash
+      super_hash = super
+      children = elements.collect do |e|
+        h = e.export_hash
+        h[:question_grid_id] = :parent_id
+        h
+      end
+
+      super_hash[:children] += children
+      super_hash
+    end
   end
 end

data/app/models/fe/question_set.rb

@@ -3,30 +3,24 @@
 module Fe
   class QuestionSet
 
-    attr_reader :elements
+    attr_reader :elements, :questions
 
     # associate answers from database with a set of elements
     def initialize(elements, answer_sheet)
       @elements = elements
       @answer_sheet = answer_sheet
-
       @questions = elements.select { |e| e.question? }
-
-      # answers = @answer_sheet.answers_by_question
-
-      @questions.each do |question|
-        question.answers = question.responses(answer_sheet) #answers[question.id]
-      end
-      @questions
     end
 
     # update with responses from form
     def post(params, answer_sheet)
-      questions_indexed = @questions.index_by {|q| q.id}
+      questions_indexed = @questions.index_by(&:id)
 
       # loop over form values
       params ||= {}
-      params.each do |question_id, response|
+      # we only assign answers to questions from this set, so it's fine to use to_unsafe_h here.  If we don't,
+      # the kind_of?(Hash) checks will fail as per rails 5
+      params.to_unsafe_h.each do |question_id, response|
         next if questions_indexed[question_id.to_i].nil? # the rare case where a question was removed after the app was opened.
         # update each question with the posted response
         questions_indexed[question_id.to_i].set_response(posted_values(response), answer_sheet)
@@ -53,6 +47,51 @@ module Fe
       end
     end
 
+    # options should contain:
+    # 
+    # :filter - Array of symbols, ex [ :confidential ]
+    #
+    #           These will be called on each element to determine if they match the filter
+    #           An element matches the filter using an AND condition, ie. if all the methods
+    #           in the array return true
+    # 
+    # :filter_default - Either :show or :hide
+    #
+    #           If show, all elements are shown by default and hidden if they match the filter.
+    #           If hide, all elements are hidden by default and shown if they match the filter.
+    #
+    def set_filter(options = {})
+      return if options.nil? || options.empty?
+
+      filter = options.delete(:filter)
+      unless filter && filter.is_a?(Array)
+        raise("expect options[:filter] to be an array")
+      end
+      filter_default = options.delete(:filter_default)
+      unless filter_default && [:show, :hide].include?(filter_default)
+        raise("expect options[:filter_default] to be either :show or :hide")
+      end
+
+      @filter = filter
+      @filter_default = filter_default
+
+      matching_ids = []
+      @elements.each do |e|
+        if e.matches_filter(@filter) && !matching_ids.include?(e.id)
+          matching_ids << e.id
+          matching_ids += e.all_elements.collect(&:id)
+        end
+      end
+
+      case filter_default
+      when :show
+        @elements = @elements.to_a.reject{ |e| matching_ids.include?(e.id) }
+      when :hide
+        @elements = @elements.to_a.select{ |e| matching_ids.include?(e.id) }
+      end
+
+      initialize(@elements, @answer_sheet)
+    end
 
     private
 
@@ -69,7 +108,9 @@ module Fe
         end
       elsif param.kind_of?(Hash)
         # from Hash with multiple answers per question
-        values = param.values.map {|v| CGI.unescape(v)}
+        # If value is also a hash, use the value hash without escaping or anything,
+        # so that custom elements can be implemented by handling set_response.
+        values = param.values.map {|v| v.is_a?(Hash) ? v : CGI.unescape(v)}
       elsif param.kind_of?(String)
         values = [CGI.unescape(param)]
       end
@@ -77,6 +118,5 @@ module Fe
       # Hash may contain empty string to force post for no checkboxes
   #    values = values.reject {|r| r == ''}
     end
-
   end
 end