fe 0.0.4 → 1.0.0

data/app/controllers/fe/concerns/admin/question_sheets_controller_concern.rb

@@ -0,0 +1,112 @@
+module Fe::Admin::QuestionSheetsControllerConcern
+  extend ActiveSupport::Concern
+
+  begin
+    included do
+      before_filter :check_valid_user
+      before_filter :get_question_sheet, :only => [:show, :archive, :unarchive, :destroy, :edit, :update, :duplicate]
+      layout 'fe/fe.admin'
+    end
+  rescue ActiveSupport::Concern::MultipleIncludedBlocks
+  end
+
+  # list of all questionnaires/forms to edit
+  # GET /question_sheets
+  def index
+    @active_question_sheets = Fe::QuestionSheet.active.order('label')
+    @archived_question_sheets = Fe::QuestionSheet.archived.order('label')
+
+    respond_to do |format|
+      format.html # index.rhtml
+      format.xml  { render :xml => @question_sheets.to_xml }
+    end
+  end
+
+  def archive
+    @question_sheet.update_attribute(:archived, true)
+    redirect_to :back
+  end
+
+  def unarchive
+    @question_sheet.update_attribute(:archived, false)
+    redirect_to :back
+  end
+
+  def duplicate
+    @question_sheet.duplicate
+    redirect_to :back
+  end
+
+  # entry point: display form designer with page 1 and panels loaded
+  # GET /question_sheets/1
+  def show
+    @all_pages = @question_sheet.pages
+    @page = @all_pages[0]
+
+    respond_to do |format|
+      format.html # show.rhtml
+      format.xml  { render :xml => @question_sheet.to_xml }
+    end
+  end
+
+  # create sheet with inital page, redirect to show
+  # POST /question_sheets
+  def create
+    @question_sheet = Fe::QuestionSheet.new_with_page
+
+    respond_to do |format|
+      if @question_sheet.save
+        format.html { redirect_to fe_admin_question_sheet_path(@question_sheet) }
+        format.xml  { head :created, :location => admin_question_sheet_path(@question_sheet) }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @question_sheet.errors.to_xml }
+      end
+    end
+  end
+
+
+  # display sheet properties panel
+  # GET /question_sheets/1/edit
+  def edit
+
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  # save changes to properties panel (label, language)
+  # PUT /question_sheets/1
+  def update
+    params.require(:fe_question_sheet).permit!
+
+    respond_to do |format|
+      if @question_sheet.update_attributes(params[:fe_question_sheet])
+        format.html { redirect_to fe_admin_question_sheet_path(@question_sheet) }
+        format.js
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.js { render :action => "error.rjs"}
+        format.xml  { render :xml => @question_sheet.errors.to_xml }
+      end
+    end
+  end
+
+  # mark sheet as destroyed
+  # DELETE /question_sheets/1
+  def destroy
+    @question_sheet.destroy
+
+    respond_to do |format|
+      format.html { redirect_to fe_admin_question_sheets_path }
+      format.xml  { head :ok }
+    end
+  end
+
+  protected
+  def get_question_sheet
+    @question_sheet = Fe::QuestionSheet.find(params[:id])
+  end
+end
+

data/app/controllers/fe/concerns/answer_pages_controller_concern.rb

@@ -39,7 +39,8 @@ module Fe::AnswerPagesControllerConcern
       end
     end
     @presenter.active_page = nil
-    @answer_sheet.touch
+    @answer_sheet.update(locale: session[:locale])
+    @saved_at_timestamp = [@answer_sheet.updated_at, @answer_sheet.answers.maximum(:updated_at)].compact.max
     respond_to do |format|
       format.js
       #format.html

data/app/controllers/fe/concerns/answer_sheets_controller_concern.rb

@@ -22,7 +22,7 @@ module Fe::AnswerSheetsControllerConcern
     @question_sheet = Fe::QuestionSheet.find(params[:question_sheet_id])
     @answer_sheet = @question_sheet.answer_sheets.create
 
-    redirect_to edit_answer_sheet_path(@answer_sheet)
+    redirect_to edit_fe_answer_sheet_path(@answer_sheet)
   end
 
   # display answer sheet for data capture (page 1)

data/app/controllers/fe/concerns/application_controller_concern.rb

@@ -4,6 +4,7 @@ module Fe::ApplicationControllerConcern
   begin
     included do
       helper_method :fe_user
+      before_filter :set_locale
     end
   rescue ActiveSupport::Concern::MultipleIncludedBlocks
   end
@@ -18,6 +19,18 @@ module Fe::ApplicationControllerConcern
     @fe_user
   end
 
+  def extract_locale_from_accept_language_header
+    request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^[a-z]{2}/).first if request.env['HTTP_ACCEPT_LANGUAGE'].present?
+  end
+
+  def set_locale
+    session[:locale] = params[:locale] if params[:locale]
+    session[:locale] ||= extract_locale_from_accept_language_header || I18n.default_locale
+    if @answer_sheet
+      session[:locale] = I18n.default_locale unless @answer_sheet.languages.include?(session[:locale])
+    end
+  end
+
   def current_person
     #raise "no user" unless current_user
     return nil unless current_user

data/app/controllers/fe/reference_sheets_controller.rb

@@ -1,6 +1,8 @@
+# TODO determine how this relates to Fe::ReferencesController and if we can delete one of the two
 class Fe::ReferenceSheetsController < Fe::AnswerSheetsController
   skip_before_filter :ssm_login_required, :login
   before_filter :edit_only, :except => [:edit]
+
   def edit
     @reference_sheet = @answer_sheet
     unless @answer_sheet

data/app/controllers/fe/references_controller.rb

@@ -1,4 +1,5 @@
 # for Reference completing answer sheet
+# TODO determine how this relates to Fe::ReferenceSheetsController and if we can delete one of the two
 module Fe
   class ReferencesController < ApplicationController
     skip_before_filter :cas_filter

data/app/helpers/fe/application_helper.rb

@@ -54,5 +54,10 @@ module Fe
 
        content_tag(:a, name, html_options.merge(:href => href, :onclick => onclick))
     end
+
+    def error_messages_for(model)
+      record = instance_variable_get(:"@#{(model.is_a?(ActiveRecord::Base) ? model.class : model).to_s.underscore}")
+      render "layouts/fe/error_messages_for", record: record
+    end
   end
 end

data/app/mailers/fe/notifier.rb

@@ -6,12 +6,19 @@ module Fe
       email_template = EmailTemplate.find_by_name(template_name)
 
       if email_template.nil?
-        raise "Email Template #{template_name} could not be found"
+        raise "Email Template '#{template_name}' could not be found"
       else
-        mail(:to => p_recipients,
+        set_format = options.delete(:format)
+        mail({:to => p_recipients,
              :from => p_from,
-             :subject => Liquid::Template.parse(email_template.subject).render(template_params),
-             :body => Liquid::Template.parse(email_template.content).render(template_params))
+             :subject => Liquid::Template.parse(email_template.subject).render(template_params)}.merge(options)) do |format|
+          case set_format.to_s
+          when 'html'
+            format.html { render html: Liquid::Template.parse(email_template.content).render(template_params) }
+          else
+            format.text { render text: Liquid::Template.parse(email_template.content).render(template_params) }
+          end
+        end
         @recipients = p_recipients
         @from = p_from
         @subject = Liquid::Template.parse(email_template.subject).render(template_params)

data/app/models/answer_sheet.rb

@@ -0,0 +1,2 @@
+class AnswerSheet < ActiveRecord::Base
+end

data/app/models/fe/application.rb

@@ -2,9 +2,10 @@ require 'aasm'
 
 # a visitor applies to a sleeve (application)
 class Fe::Application < Fe::AnswerSheet
+
   self.table_name = "#{Fe.table_name_prefix}applications"
 
-  belongs_to :applicant, :class_name => "Person", :foreign_key => "applicant_id"
+  belongs_to :applicant, foreign_key: 'person_id', class_name: "Person"
   has_many :references, :class_name => 'ReferenceSheet', :foreign_key => :applicant_answer_sheet_id, :dependent => :destroy
   has_one :answer_sheet_question_sheet, :foreign_key => "answer_sheet_id"
   has_many :answer_sheet_question_sheets, :foreign_key => 'answer_sheet_id'

data/app/models/fe/concerns/answer_pages_presenter_concern.rb

@@ -48,6 +48,15 @@ module Fe
       link
     end
 
+    def prev_page
+      active_page_dom_id = active_page_link.dom_id
+
+      this_page = @page_links.find {|p| p.dom_id == active_page_dom_id}
+      index = @page_links.index(this_page)
+      return nil if index == 0
+      @page_links.at( index - 1 ) unless this_page.nil?
+    end
+
     def next_page
       active_page_dom_id = active_page_link.dom_id
 
@@ -81,7 +90,7 @@ module Fe
     end
 
     def new_page_link(answer_sheet, page, a = nil)
-      Fe::PageLink.new(page.label, edit_fe_answer_sheet_page_path(answer_sheet, page, :a => a), dom_page(answer_sheet, page), page) if page
+      Fe::PageLink.new(edit_fe_answer_sheet_page_path(answer_sheet, page, :a => a), dom_page(answer_sheet, page), page) if page
     end
 
     protected

data/app/models/fe/concerns/answer_sheet_concern.rb

@@ -4,15 +4,41 @@ module Fe
 
     begin
       included do
-        has_many :answer_sheet_question_sheets, :foreign_key => 'answer_sheet_id'
-        has_many :question_sheets, :through => :answer_sheet_question_sheets
-        has_many :answers, :foreign_key => 'answer_sheet_id'
-        has_many :reference_sheets, :foreign_key => "applicant_answer_sheet_id"
-        has_many :payments, :foreign_key => "application_id"
+        has_many :answer_sheet_question_sheets, foreign_key: 'answer_sheet_id', class_name: '::Fe::AnswerSheetQuestionSheet'
+        has_many :question_sheets, through: :answer_sheet_question_sheets, class_name: 'Fe::QuestionSheet'
+        has_many :answers, ->(answer_sheet) {
+          question_sheet_ids = answer_sheet.question_sheet_ids
+
+          if question_sheet_ids.any?
+            element_ids = Fe::Page.joins(:question_sheet).where(question_sheet_id: question_sheet_ids).pluck(:all_element_ids).compact
+            element_ids = element_ids.collect{ |e| e.split(',') }.flatten
+          end
+
+          unless question_sheet_ids.any? && element_ids.any?
+            # an answer sheet not assigned to a question sheet, or assigned to
+            # a question sheet with no elements should not return any answers
+            return where('false')
+          end
+
+          where('question_id' => element_ids)
+
+        }, foreign_key: 'answer_sheet_id', class_name: '::Fe::Answer'
+        has_many :reference_sheets, :foreign_key => 'applicant_answer_sheet_id', class_name: 'Fe::ReferenceSheet'
+        has_many :payments, :foreign_key => 'application_id', class_name: 'Fe::Payment'
       end
     rescue ActiveSupport::Concern::MultipleIncludedBlocks
     end
 
+    def languages
+      return [] unless question_sheets.first
+
+      unless @languages
+        @languages = question_sheets.first.languages
+        question_sheets[1..-1].each { |qs| @languages &= qs.languages.select(&:present?) }
+      end
+      @languages
+    end
+
     def complete?
       !completed_at.nil?
     end
@@ -28,7 +54,7 @@ module Fe
     end
 
     def pages
-      Page.where(:question_sheet_id => question_sheets.collect(&:id))
+      Page.where(:question_sheet_id => question_sheets.collect(&:id)).order('number')
     end
 
     def completely_filled_out?
@@ -44,12 +70,16 @@ module Fe
     end
 
     def percent_complete
-      num_questions = question_sheets.inject(0.0) { |sum, qs| qs.nil? ? sum : qs.questions.length + sum }
+      num_questions = question_sheets.inject(0.0) { |sum, qs| qs.nil? ? sum : qs.questions_count + sum }
       return 0 if num_questions == 0
-      num_answers = answers.where("value IS NOT NULL && value != ''").select("DISTINCT question_id").count
+      num_answers = answers.where("(value IS NOT NULL) AND (value != '')").select("DISTINCT question_id").count
       [ [ (num_answers.to_f / num_questions.to_f * 100.0).to_i, 100 ].min, 0 ].max
     end
 
     def collat_title() "" end
+
+    def question_sheet_ids
+      question_sheets.collect(&:id)
+    end
   end
 end

data/app/models/fe/concerns/choice_field_concern.rb

@@ -1,9 +1,11 @@
 require 'net/http'
+# :nocov:
 begin
   require 'xml/libxml'
 rescue LoadError
   require 'rexml/document'
 end
+# :nocov:
 
 module Fe
   module ChoiceFieldConcern
@@ -17,22 +19,23 @@ module Fe
     end
 
     # Returns choices stored one per line in content field
-    def choices
+    def choices(locale = nil)
       retVal = Array.new
       if ['yes-no', 'acceptance'].include?(self.style)
-        return [["Yes",1],["No",0]]
-      elsif !source.blank?
+        return [[_('Yes'),1],[_('No'),0]]
+      elsif source.present?
         begin
           doc = XML::Document.file(source)
           options = doc.find(text_xpath).collect { |n| n.content }
           values = doc.find(value_xpath).collect { |n| n.content }
           retVal = [options, values].transpose
-        rescue NameError
+        rescue NameError, LibXML::XML::Error
           doc = REXML::Document.new Net::HTTP.get_response(URI.parse(source)).body
-          retVal = [ doc.elements.collect(text_xpath){|c|c.text}, doc.elements.collect(value_xpath){|c|c.text} ].transpose.sort
+          retVal = [ doc.elements.collect(text_xpath){|c|c.text}, doc.elements.collect(value_xpath){|c|c.text} ].transpose
         end
-      elsif !content.nil?
-        content.split("\n").each do |opt|
+      elsif content.present?
+        choices = content_translations[locale] || content
+        choices.split("\n").each do |opt|
           pair = opt.strip.split(";").reverse!
           pair[1] ||= pair[0]
           retVal << pair
@@ -124,18 +127,22 @@ module Fe
     def conditional_match(answer_sheet)
       displayed_response = display_response(answer_sheet)
       (is_true(displayed_response) && is_true(conditional_answer)) ||
-        (is_false(displayed_response) && is_false(conditional_answer)) ||
+        (is_response_false(answer_sheet) && is_false(conditional_answer)) ||
         (displayed_response == conditional_answer)
     end
 
+    def is_response_false(answer_sheet)
+      is_false(display_response(answer_sheet))
+    end
+
     protected
     def is_true(val)
-      [1,'1',true,'true','Yes','yes'].include?(val) # note: true = anything but false | nil
+      ['1','true','yes'].include?(val.to_s.downcase)
     end
 
     def is_false(val)
       # returns false if false (a bit odd)
-      [0,'0',false,'false','No','no'].include?(val)
+      ['0','false','no'].include?(val.to_s.downcase)
     end
 
   end

data/app/models/fe/date_field.rb

@@ -35,7 +35,7 @@ module Fe
 
     def format_date_response(answer_sheet = nil)
       r = response(answer_sheet)
-      r = r.strftime("%m/%d/%Y") unless r.blank?
+      r = r.strftime("%Y-%m-%d") unless r.blank?
       r
     end
 

data/app/models/fe/element.rb

@@ -4,23 +4,29 @@ module Fe
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
     belongs_to :question_grid,
-               :class_name => "Fe::QuestionGrid",
-               :foreign_key => "question_grid_id"
+               class_name: "Fe::QuestionGrid"
+
+    belongs_to :question_grid_with_total,
+               class_name: "Fe::QuestionGridWithTotal",
+               foreign_key: "question_grid_id"
 
     belongs_to :choice_field,
-               :class_name => "Fe::ChoiceField",
-               :foreign_key => "choice_field_id"
+               class_name: "Fe::ChoiceField"
+
+    has_many :choice_field_children, foreign_key: 'choice_field_id',
+      class_name: 'Fe::Element'
 
     belongs_to :question_sheet, :foreign_key => "related_question_sheet_id"
 
-    belongs_to :conditional, :polymorphic => true
+    belongs_to :conditional, polymorphic: true
 
     self.inheritance_column = :kind
 
-    has_many :page_elements, :dependent => :destroy
-    has_many :pages, :through => :page_elements
+    has_many :page_elements, dependent: :destroy
+    has_many :pages, through: :page_elements
 
     scope :active, -> { select("distinct(#{Fe::Element.table_name}.id), #{Fe::Element.table_name}.*").where(Fe::QuestionSheet.table_name + '.archived' => false).joins({:pages => :question_sheet}) }
+    scope :questions, -> { where("kind NOT IN('Fe::Paragraph', 'Fe::Section', 'Fe::QuestionGrid', 'Fe::QuestionGridWithTotal')") }
 
     validates_presence_of :kind
     validates_presence_of :style
@@ -32,8 +38,13 @@ module Fe
 
     before_validation :set_defaults, :on => :create
     before_save :set_conditional_element
+    after_save :update_page_all_element_ids
     after_save :update_any_previous_conditional_elements
 
+    serialize :label_translations, Hash
+    serialize :tip_translations, Hash
+    serialize :content_translations, Hash
+
     # HUMANIZED_ATTRIBUTES = {
     #   :slug => "Variable"
     # }changed.include?('address1')
@@ -41,6 +52,23 @@ module Fe
     # def self.human_attrib_name(attr)
     #   HUMANIZED_ATTRIBUTES[attr.to_sym] || super
     # end
+    def label(locale = nil)
+      label_translations[locale] || self[:label]
+    end
+
+    def content(locale = nil)
+      content_translations[locale] || self[:content]
+    end
+
+    def tooltip(locale = nil)
+      tip_translations[locale] || self[:tooltip]
+    end
+
+    # returns all pages this element is on, whether that be directly, through a grid, or as a choice field conditional option
+    def pages_on
+      all_pages = pages.reload + [question_grid, question_grid_with_total, choice_field].compact.collect(&:pages_on)
+      all_pages.flatten.uniq
+    end
 
     def has_response?(answer_sheet = nil)
       false
@@ -52,7 +80,7 @@ module Fe
           unless eval("answer_sheet." + self.object_name + ".nil?")
             klass = eval("answer_sheet." + self.object_name + ".class")
             column = klass.columns_hash[self.attribute_name]
-            column.limit
+            return column.limit
           end
         rescue
           nil
@@ -61,24 +89,54 @@ module Fe
     end
 
     # assume each element is on a question sheet only once to make things simpler. if not, just take the first one
-    def previous_element(question_sheet)
-      page_element = page_elements.joins(page: :question_sheet).where("#{Fe::QuestionSheet.table_name}.id" => question_sheet.id).first
-      #binding.pry if page_element.nil?
-      return unless page_element
-      index = page_element.page.elements.index(self)
-      if index > 0 && prev_el = page_element.page.elements[index-1]
-        return prev_el
+    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
 
-    def required?(answer_sheet = nil)
-      if answer_sheet && 
-        self.question_grid.nil? && 
-        (prev_el = previous_element(answer_sheet.question_sheet)) && 
-        prev_el.is_a?(Fe::Question) && 
-        prev_el.class != Fe::QuestionGrid && 
-        prev_el.conditional_match(answer_sheet)
+    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
+
+    def hidden_by_choice_field?(answer_sheet)
+      choice_field.present? &&
+        choice_field.is_a?(Fe::ChoiceField) &&
+        choice_field.is_response_false(answer_sheet)
+    end
+
+    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
+    def visible?(answer_sheet = nil, page = nil, prev_el = nil)
+      !hidden?(answer_sheet, page, prev_el)
+    end
+
+    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
+    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
 
+    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
+    def required?(answer_sheet = nil, page = nil, prev_el = nil)
+      if hidden?(answer_sheet, page, prev_el)
         return false
       else
         required == true
@@ -130,7 +188,8 @@ module Fe
         when "Fe::ChoiceField"
           new_element.choice_field_id = parent.id
       end
-      new_element.save(:validate => false)
+      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
@@ -144,6 +203,7 @@ module Fe
     # include nested elements
     def all_elements
       if respond_to?(:elements)
+        elements.reload
         (elements + elements.collect(&:all_elements)).flatten
       else
         []
@@ -151,6 +211,7 @@ module Fe
     end
 
     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
 
@@ -167,27 +228,40 @@ module Fe
     def set_conditional_element
       case conditional_type
       when "Fe::Element"
-        pages.reload.each do |page|
-          index = page.elements.index(self)
-          if index && index < page.elements.length - 1
-            self.conditional_id = page.elements[index+1].id
+        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
 
     def update_any_previous_conditional_elements
-      pages.reload.each do |page|
-        index = page.elements.index(self)
+      pages_on.each do |page|
+        index = page.all_element_ids_arr.index(self.id)
         if index && index > 0
-          prev_el = page.elements[index-1]
+          prev_el = Fe::Element.find(page.all_element_ids_arr[index-1])
           if prev_el.conditional_type == "Fe::Element"
-            prev_el.update_attribute(:conditional_id, id)
+            prev_el.update_column(:conditional_id, id)
           end
         end
       end
     end
 
+    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
+
     protected
 
     def set_defaults