fe 0.0.4 → 2.0.0

data/app/controllers/fe/admin/question_sheets_controller.rb

@@ -1,107 +1,6 @@
 # QuestionSheets is used exclusively on the administration side to design a Questionniare
 #  which can than be instantiated as an AnswerSheet for data capture on the front-end
-
 class Fe::Admin::QuestionSheetsController < ApplicationController
-  before_filter :check_valid_user
-  before_filter :get_question_sheet, :only => [:show, :archive, :unarchive, :destroy, :edit, :update, :duplicate]
-  layout 'fe/fe.admin'
-
-  # 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
+  include Fe::Admin::QuestionSheetsControllerConcern
 end
+

data/app/controllers/fe/reference_pages_controller.rb

@@ -1,12 +1,12 @@
 # gather reference information from Applicant
 module Fe
   class ReferencePagesController < ApplicationController
-    skip_before_filter :cas_filter
-    skip_before_filter :authentication_filter
-    
+    skip_before_action :cas_filter, raise: false
+    skip_before_action :authentication_filter, raise: false
+
     layout nil
-    
-    before_filter :setup
+
+    before_action :setup
 
     MONTHS_KNOWN_OPTIONS = [
       ["3 months", 3],
@@ -15,27 +15,27 @@ module Fe
       ["2 years", 24],
       ["3 or more years", 36]
     ]
-    
+
     # Allow applicant to edit reference
     # /applications/1/reference_page/edit
     # js: provide a partial to replace the answer_sheets page area
     # html?: return a full page for editing reference independantly (after submission)
     def edit
       @references = @application.reference_sheets
-      
+
       # NEXT: skipping all the fancy answer sheets stuff since all custom pages come after those
       @next_page = next_custom_page(@application, 'reference_page')
     end
-    
+
     def update
       #update_references
       head :ok
     end
-    
+
     private
     def setup
       @application = Application.find(params[:application_id])
-    end  
-    
+    end
+
   end
 end

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]
+  skip_before_action :ssm_login_required, :login, raise: false
+  before_action :edit_only, except: [:edit]
+
   def edit
     @reference_sheet = @answer_sheet
     unless @answer_sheet
@@ -16,13 +18,13 @@ class Fe::ReferenceSheetsController < Fe::AnswerSheetsController
     @page = @presenter.pages.first
     render 'fe/answer_sheets/edit', layout: 'fe/application'
   end
-  
+
   protected
     def get_answer_sheet
       @answer_sheet ||= Fe::ReferenceSheet.find_by_id_and_access_key(params[:id], params[:a])
       return false unless @answer_sheet
     end
-    
+
     def edit_only
       return false
     end

data/app/controllers/fe/references_controller.rb

@@ -1,49 +1,50 @@
 # 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
-    skip_before_filter :authentication_filter
-    
-    before_filter :setup
-    
+    skip_before_action :cas_filter, raise: false
+    skip_before_action :authentication_filter, raise: false
+
+    before_action :setup
+
     layout 'public'
 
     # AnswerSheet for reference to fill in
     # /applications/1/references/{token}
     def edit
       ref = Fe::ReferenceSheet.find_by_access_key(params[:id])
-      redirect_to edit_fe_reference_sheet_path(ref, :a => params[:id])
+      redirect_to edit_fe_reference_sheet_path(ref, a: params[:id])
     end
 
     # final submission
     def submit
       @reference = @application.references.find(params[:id])
       @reference.submit!
-      
+
       # Send Reference Thank You
       Fe::Notifier.notification(@reference.email,
-                                    Fe.from_email, 
-                                    "Reference Thank You", 
-                                    {'reference_full_name' => @reference.name, 
+                                    Fe.from_email,
+                                    "Reference Thank You",
+                                    {'reference_full_name' => @reference.name,
                                      'applicant_full_name' => @application.applicant.informal_full_name}).deliver
 
-      
+
       # Send Reference Completion Notice
       Fe::Notifier.notification(@application.applicant.email,
-                                    Fe.from_email, 
-                                    "Reference Complete", 
-                                    {'reference_full_name' => @reference.name, 
+                                    Fe.from_email,
+                                    "Reference Complete",
+                                    {'reference_full_name' => @reference.name,
                                      'applicant_full_name' => @application.applicant.informal_full_name,
                                      'reference_submission_date' => @reference.submitted_at.strftime("%m/%d/%Y")}).deliver
-      
+
     end
 
-    
+
     def show
       @reference = @application.references.find_by_access_key(params[:id])
 
       if @reference.nil?
-        render :action => :edit
+        render action: :edit
       else
         @answer_sheet = @reference
         @question_sheet = @answer_sheet.question_sheet
@@ -57,11 +58,11 @@ module Fe
         end
       end
     end
-    
+
     def send_invite
       # Save references on page first
       #update_references
-      
+
       @reference = Fe::ReferenceSheet.find(params[:id])
       send_reference_invite(@reference)
     end

data/app/controllers/fe/submit_pages_controller.rb

@@ -1,14 +1,14 @@
 class Fe::SubmitPagesController < ApplicationController
 
-  before_filter :setup
-  skip_before_filter :get_answer_sheet
+  before_action :setup
+  skip_before_action :get_answer_sheet, raise: false
 
   layout nil
-  
+
   def edit
     @next_page = next_custom_page(@application, 'submit_page')
   end
-  
+
   # save any changes on the submit_page (for auto-save, no server-validation)
   def update
     head :ok
@@ -18,5 +18,5 @@ class Fe::SubmitPagesController < ApplicationController
 
   def setup
     @application = @answer_sheet = Fe.answer_sheet_class.constantize.find(params[:application_id]) unless @application
-  end  
+  end
 end

data/app/helpers/fe/answer_pages_helper.rb

@@ -13,7 +13,7 @@ module Fe::AnswerPagesHelper
   def load_page_js(page_link)
     return '' if page_link.nil?
     
-    %{$.fe.pageHandler.loadPage('#{page_link.dom_id}','#{page_link.load_path}')}
+    %{fe.pageHandler.loadPage('#{page_link.dom_id}','#{page_link.load_path}')}
   end
   
 end

data/app/helpers/fe/application_helper.rb

@@ -37,12 +37,12 @@ module Fe
     end
 
     def tip(t)
-      image_tag('fe/icons/question-balloon.png', :title => t, :class => 'tip')
+      image_tag('fe/icons/question-balloon.png', title: t, class: 'tip')
     end
 
     def spinner(extra = nil)
       e = extra ? "spinner_#{extra}" : 'spinner'
-      image_tag('spinner.gif', :id => e, :style => 'display:none', :class => 'spinner')
+      image_tag('spinner.gif', id: e, style: 'display:none', class: 'spinner')
     end
 
     def link_to_function(name, *args, &block)
@@ -52,7 +52,12 @@ module Fe
        onclick = "#{"#{html_options[:onclick]}; " if html_options[:onclick]}#{function}; return false;"
        href = html_options[:href] || '#'
 
-       content_tag(:a, name, html_options.merge(:href => href, :onclick => onclick))
+       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/jobs/fe/update_reference_sheet_visibility_job.rb

@@ -0,0 +1,11 @@
+class Fe::UpdateReferenceSheetVisibilityJob < ActiveJob::Base
+  def perform(answer_sheet, question_ids)
+    answer_sheet.question_sheets_all_reference_elements.each do |r|
+      if (r.visibility_affecting_element_ids & question_ids).any?
+        answer_sheet.all_references.where(question_id: r.id).each do |ref|
+          ref.update_visible
+        end
+      end
+    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,
-             :from => p_from,
-             :subject => Liquid::Template.parse(email_template.subject).render(template_params),
-             :body => Liquid::Template.parse(email_template.content).render(template_params))
+        set_format = options.delete(:format)
+        mail({to: p_recipients,
+             from: p_from,
+             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 plain: 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 < ApplicationRecord
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/{fe/concerns → concerns/fe}/answer_concern.rb

@@ -6,8 +6,8 @@ module Fe
     begin
       included do
 
-        belongs_to :answer_sheet
-        belongs_to :question, :class_name => "Element", :foreign_key => "question_id"
+        belongs_to :answer_sheet, optional: true
+        belongs_to :question, optional: true, class_name: "Element", foreign_key: "question_id"
 
         before_save :set_value_from_filename
       end

data/app/models/{fe/concerns → concerns/fe}/answer_pages_presenter_concern.rb

@@ -9,11 +9,11 @@ module Fe
     rescue ActiveSupport::Concern::MultipleIncludedBlocks
     end
 
-    def initialize(controller, answer_sheets, a = nil, custom_pages = nil)
+    def initialize(controller, answer_sheets, a = nil, custom_pages = nil, show_hidden_pages = false)
       super(controller)
       @answer_sheets = Array.wrap(answer_sheets)
       @active_answer_sheet = @answer_sheets.first
-      initialize_pages(@active_answer_sheet)
+      initialize_pages(@active_answer_sheet, show_hidden_pages)
 
       @page_links = page_list(@answer_sheets, a, custom_pages)
     end
@@ -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
 
@@ -63,10 +72,11 @@ module Fe
       end
     end
 
-    def initialize_pages(answer_sheet)
+    def initialize_pages(answer_sheet, show_hidden_pages = false)
       @pages = []
       answer_sheet.question_sheets.each do |qs|
-        qs.pages.visible.each do |page|
+        pages = show_hidden_pages ? qs.pages : qs.pages.visible
+        pages.each do |page|
           @pages << page
         end
       end
@@ -81,7 +91,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/concerns/fe/answer_sheet_concern.rb

@@ -0,0 +1,125 @@
+module Fe
+  module AnswerSheetConcern
+    extend ActiveSupport::Concern
+
+    begin
+      included do
+        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
+
+    # answers for this sheet, grouped by question id
+    def answers_by_question
+      @answers_by_question ||= answers.group_by { |answer| answer.question_id }
+    end
+
+    # Convenience method if there is only one question sheet in your system
+    def question_sheet
+      question_sheets.first
+    end
+
+    def pages
+      Page.where(question_sheet_id: question_sheets.collect(&:id)).visible.order('number')
+    end
+
+    def completely_filled_out?
+      pages.all? {|p| p.complete?(self)}
+    end
+
+    def has_answer_for?(question_id)
+      !answers_by_question[question_id].nil?
+    end
+
+    def reference?
+      false
+    end
+
+    def percent_complete(required_only = true, restrict_to_pages = [])
+      # build an element to page lookup using page's cached all_element_ids
+      # this will make the hidden? calls on element faster because we can pass the page
+      # (the page builds a list of hidden elements for quick lookup)
+      elements_to_pages = {}
+      pages = question_sheets.collect(&:pages).flatten
+      pages = pages & restrict_to_pages if restrict_to_pages.present?
+      pages.each do |p|
+        p.all_element_ids_arr.each do |e_id|
+          elements_to_pages[e_id] = p
+        end
+      end
+
+      # determine which questions should count towards the questions total in the percent calculation
+      countable_questions = question_sheets.collect{ |qs| qs.all_elements.questions }.flatten
+      countable_questions.select!{ |e| elements_to_pages[e.id] } if restrict_to_pages.present?
+      countable_questions.reject!{ |e| e.hidden?(self, elements_to_pages[e.id]) }
+      countable_questions.select!{ |e| e.required } if required_only
+
+      # no progress if there are no questions
+      num_questions = countable_questions.length
+      return 0 if num_questions == 0
+
+      # count questions with answers in Fe::Answer
+      answers = self.answers.where("(question_id IN (?) AND value IS NOT NULL) AND (value != '')", countable_questions.collect(&:id))
+      answered_question_ids = answers.pluck(Arel.sql('distinct(question_id)'))
+
+      # need to look for answers for the remaining questions using has_response?
+      # so that questions with object_name/attribute_name set are counted
+      other_answered_questions = countable_questions.reject{ |e| answered_question_ids.include?(e.id) }
+      other_answered_questions.select!{ |e| e.has_response?(self) }
+
+      # count total
+      num_answers = answered_question_ids.count + other_answered_questions.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
+
+    def question_sheets_all_reference_elements
+      # forms are generally not changed often so caching on the last updated elementd
+      # will provide a good balance of speed and cache invalidation
+      element_ids = Rails.cache.fetch(question_sheets + ['answer_sheet#answer_sheet_all_reference_elements', Fe::Element.order('updated_at desc, id desc').first]) do
+        question_sheets.compact.collect { |q| q.all_elements.reference_kinds.pluck(:id) }.flatten
+      end
+
+      Fe::Element.find(element_ids)
+    end
+  end
+end