fe 0.0.4 → 2.0.0

data/app/models/fe/page.rb

@@ -1,45 +1,51 @@
 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) },
-             :dependent => :destroy
+             dependent: :destroy
 
     has_many :elements, -> { order(Fe::PageElement.table_name + '.position') },
-             :through => :page_elements
+             through: :page_elements
 
     has_many :question_grid_with_totals, -> { where("kind = 'Fe::QuestionGridWithTotal'") },
-             :through => :page_elements,
-             :source => :element
+             through: :page_elements,
+             source: :element
 
-    has_many :questions, -> { where("kind NOT IN('Fe::Paragraph', 'Fe::Section', 'Fe::QuestionGrid', 'Fe::QuestionGridWithTotal')") },
-             :through => :page_elements,
-             :source => :element
+    has_many :questions, -> { questions.order(Fe::PageElement.table_name + '.position') },
+             through: :page_elements,
+             source: :element
 
     has_many :question_grids, -> { where("kind = 'Fe::QuestionGrid'") },
-             :through => :page_elements,
-             :source => :element
+             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
     # could set multiple conditions to influence this question, in which case all must be met
@@ -52,8 +58,27 @@ 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
+
+    # returns true if there is a question element on the page, including one inside a grid
     def has_questions?
-      questions.present? || question_grids.present? || question_grid_with_totals.present?
+      all_questions.any?
+    end
+
+    def all_questions
+      all_elements.questions
     end
 
     def questions_before_position(position)
@@ -62,38 +87,120 @@ module Fe
 
     # Include nested elements
     def all_elements
-      (elements + elements.collect(&:all_elements)).flatten
+      ids = all_element_ids_arr
+      order = ids.collect{ |id| "id=#{id} DESC" }.join(', ')
+      ids.present? ? Element.where(id: ids).order(Arel.sql(order)) : Element.where("1 = 0")
+    end
+
+    def all_element_ids
+      rebuild_all_element_ids if self[:all_element_ids].nil?
+      self[:all_element_ids]
+    end
+
+    def all_element_ids_arr
+      @all_element_ids_arr ||= all_element_ids.split(',').collect(&:to_i)
+    end
+
+    def rebuild_all_element_ids
+      self.update_column :all_element_ids, elements.collect{ |e| [e] + e.all_elements }.flatten.collect(&:id).join(',')
     end
 
     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 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
+      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 question_sheet.hidden_pages(answer_sheet).include?(self)
-      prev_el = nil
-      all_elements.all? {|e| 
-        complete = !e.required? || (prev_el && prev_el.conditional == e && !prev_el.conditional_match(answer_sheet)) || e.has_response?(answer_sheet)
-        prev_el = e
-        complete
+      return true if hidden?(answer_sheet)
+
+      all_elements.all? {|e|
+        e.hidden?(answer_sheet, self) || !e.required?(answer_sheet, self) || e.has_response?(answer_sheet)
       }
     end
 
     def started?(answer_sheet)
-      all_elements.any? {|e| e.has_response?(answer_sheet)}
+      all_questions.any? {|e| e.has_response?(answer_sheet)}
     end
 
-    def has_questions?
-      all_elements.any? {|e| e.is_a?(Question)}
+    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

data/app/models/fe/page_element.rb

@@ -1,13 +1,14 @@
 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
-    belongs_to :page
+    acts_as_list scope: :page_id
+    belongs_to :page, touch: true
     belongs_to :element
 
     after_save :save_element
     before_create :set_position
+    after_destroy :rebuild_page_all_element_ids
 
     def set_position
       self.position ||= (page.page_elements.last.try(:position) + 1) || page.elements.last.try(:position) || 0
@@ -17,5 +18,9 @@ module Fe
     def save_element
       element.save!
     end
+
+    def rebuild_page_all_element_ids
+      page.rebuild_all_element_ids
+    end
   end
 end

data/app/models/fe/page_link.rb

@@ -1,15 +1,18 @@
 # represents a link to a page for the page_list sidebar or next page links
 module Fe
   class PageLink
-    attr_accessor :dom_id, :label, :load_path, :page
+    attr_accessor :dom_id, :load_path, :page
     attr_accessor :save_path  # to save current page
 
-    def initialize(label, load_path, dom_id, page)
-      @label = label
+    def initialize(load_path, dom_id, page)
       @load_path = load_path
       @dom_id = dom_id
       @page = page
     end
 
+    def label(locale = nil)
+      page.label(locale)
+    end
+
   end
 end

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,14 +1,13 @@
 module Fe
-  class Person < ActiveRecord::Base
-    belongs_to :user, :foreign_key => "fk_ssmUserId" # TODO need to migrate person columns to be more rails-like
-    has_one    :current_address, -> { where("address_type = 'current'") }, :class_name => "Fe::Address"
-    has_many   :email_addresses, :foreign_key => "person_id", :class_name => '::EmailAddress', dependent: :destroy
-    has_many   :phone_numbers, :foreign_key => "person_id", :class_name => '::PhoneNumber', dependent: :destroy
-    has_one    :current_address, -> { where("address_type = 'current'") }, :foreign_key => "person_id", :class_name => '::Fe::Address'
-    has_one    :permanent_address, -> { where("address_type = 'permanent'") }, :foreign_key => "person_id", :class_name => '::Fe::Address'
-    has_one    :emergency_address1, -> { where("address_type = 'emergency1'") }, :foreign_key => "person_id", :class_name => 'Fe::Address'
-    has_many   :addresses, :foreign_key => "person_id", dependent: :destroy
-    has_one    :application, :foreign_key => "applicant_id"
+  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
+    has_one    :permanent_address, -> { where("address_type = 'permanent'") }, class_name: '::Fe::Address', dependent: :destroy
+    has_one    :emergency_address1, -> { where("address_type = 'emergency1'") }, class_name: 'Fe::Address', dependent: :destroy
+    has_many   :addresses, dependent: :destroy
+    has_many   :applications, class_name: Fe.answer_sheet_class
 
     def emergency_address
       emergency_address1
@@ -18,15 +17,19 @@ 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
+      [ first_name, last_name ].join(' ')
     end
   end
 

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,8 +84,10 @@ module Fe
       true
     end
 
-    def locked?(params, answer_sheet, presenter)
-      return true unless ['fe/answer_pages', 'fe/reference_sheets'].include?(params['controller']) && params['action'] == 'edit'
+    # 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
         return false
@@ -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
 
@@ -169,7 +179,7 @@ module Fe
           value = values.first
           if self.is_a?(Fe::DateField) && value.present?
             begin
-              value = Date.strptime(value, (I18n.t 'date.formats.default'))
+              value = Date.strptime(value, '%Y-%m-%d')
             rescue
               raise "invalid date - " + value.inspect
             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,28 +253,24 @@ 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
       false
     end
 
-    def required?(answer_sheet = nil)
-      super
-    end
-
   end
 end

data/app/models/fe/question_grid.rb

@@ -7,10 +7,10 @@
 module Fe
   class QuestionGrid < Element
 
-    has_many :elements, -> { order('position') },
-             :class_name => "Element",
-             :foreign_key => "question_grid_id",
-             :dependent => :nullify
+    has_many :elements, -> { order('position asc, id asc') },
+             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_grid_with_total.rb

@@ -7,5 +7,20 @@
 
 module Fe
   class QuestionGridWithTotal < QuestionGrid
+    def totals(app)
+      totals = []
+      col = 0
+      row = []
+      elements.each do |el|
+        value = el.display_response(app) if el.respond_to?(:display_response) && el.display_response(app).present?
+
+        if value && value.present? # keep totals nil until there actually is a value, so that we can only display a total only if at least one row had a value
+          value = value.tr("^0-9.", '').to_f
+          totals[col] = (totals[col].present? ? totals[col] + value : value)
+        end
+        col = (col + 1) % num_cols
+      end
+      totals
+    end
   end
 end