fe 0.0.3

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

@@ -0,0 +1,106 @@
+# 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.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 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
+
+    respond_to do |format|
+      if @question_sheet.update_attributes(params[:question_sheet])
+        format.html { redirect_to 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 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/answer_pages_controller.rb

@@ -0,0 +1,3 @@
+class Fe::AnswerPagesController < ApplicationController
+  include Fe::AnswerPagesControllerConcern
+end

data/app/controllers/fe/answer_sheets_controller.rb

@@ -0,0 +1,3 @@
+class Fe::AnswerSheetsController < ApplicationController
+  include Fe::AnswerSheetsControllerConcern
+end

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

@@ -0,0 +1,80 @@
+module Fe::AnswerPagesControllerConcern
+  extend ActiveSupport::Concern
+
+  included do
+    before_filter :get_answer_sheet, :only => [:edit, :update, :save_file, :index]
+  end
+
+  def edit
+    @elements = @presenter.questions_for_page(params[:id]).elements
+    @page = Fe::Page.find(params[:id]) || Fe::Page.find_by_number(1)
+
+    render :partial => 'answer_page', :locals => { :show_first => nil }
+  end
+
+  # validate and save captured data for a given page
+  # PUT /answer_sheets/1/pages/1
+  def update
+    @page = Fe::Page.find(params[:id])
+    questions = @presenter.all_questions_for_page(params[:id])
+    questions.post(answer_params, @answer_sheet)
+
+    questions.save
+
+    @elements = questions.elements
+
+    # Save references
+
+    if params[:reference].present?
+      params[:reference].keys.each do |id|
+        reference_params = params.fetch(:reference)[id].permit(:relationship, :title, :first_name, :last_name, :phone, :email, :is_staff)
+
+        ref = @answer_sheet.reference_sheets.find(id)
+        # if the email address has changed, we have to trash the old reference answers
+        ref.attributes = reference_params
+        ref.save(:validate => false)
+      end
+    end
+    @presenter.active_page = nil
+    @answer_sheet.touch
+    respond_to do |format|
+      format.js
+      #format.html
+    end
+  end
+
+  def save_file
+    params.permit(:Filedata)
+
+    if params[:Filedata]
+      @page = Fe::Page.find(params[:id])
+      @presenter.active_page = @page
+      question = Fe::Element.find(params[:question_id])
+      answer = Fe::Answer.where(:answer_sheet_id => @answer_sheet.id, :question_id => question.id).first
+      question.answers = [answer] if answer
+
+      @answer = question.save_file(@answer_sheet, params[:Filedata])
+
+      render action: :update
+    else
+      respond_to do |format|
+        format.js { head :ok }
+      end
+    end
+  end
+
+  protected
+
+  def get_answer_sheet
+    @answer_sheet = answer_sheet_type.find(params[:answer_sheet_id])
+    @presenter = Fe::AnswerPagesPresenter.new(self, @answer_sheet, params[:a])
+  end
+
+  def answer_sheet_type
+    (params[:answer_sheet_type] || Fe.answer_sheet_class || 'AnswerSheet').constantize
+  end
+
+  def answer_params
+    params.fetch(:answers, {}).permit!
+  end
+end

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

@@ -0,0 +1,84 @@
+module Fe::AnswerSheetsControllerConcern
+  extend ActiveSupport::Concern
+
+  included do
+    layout 'application'
+    before_filter :get_answer_sheet, :only => [:edit, :show, :send_reference_invite, :submit]
+  end
+
+  # list existing answer sheets
+  def index
+
+    @answer_sheets = answer_sheet_type.order('created_at')
+
+    # drop down of sheets to capture data for
+    @question_sheets = Fe::QuestionSheet.order('label').collect {|s| [s.label, s.id]}
+  end
+
+  def create
+    @question_sheet = Fe::QuestionSheet.find(params[:question_sheet_id])
+    @answer_sheet = @question_sheet.answer_sheets.create
+
+    redirect_to edit_answer_sheet_path(@answer_sheet)
+  end
+
+  # display answer sheet for data capture (page 1)
+  def edit
+    @presenter = Fe::AnswerPagesPresenter.new(self, @answer_sheet, params[:a])
+    unless @presenter.active_answer_sheet.pages.present?
+      flash[:error] = "Sorry, there are no questions for this form yet."
+      if request.env["HTTP_REFERER"]
+        redirect_to :back
+      else
+        render :text => "", :layout => true
+      end
+    else
+      @elements = @presenter.questions_for_page(:first).elements
+      @page = @presenter.pages.first
+    end
+  end
+
+  # display captured answers (read-only)
+  def show
+    @question_sheet = @answer_sheet.question_sheet
+    pf = Fe.table_name_prefix
+    @elements = @question_sheet.pages.collect {|p| p.elements.includes(:pages).order("#{pf}pages.number,#{pf}page_elements.position").all}.flatten
+    @elements = Fe::QuestionSet.new(@elements, @answer_sheet).elements.group_by{ |e| e.pages.first }
+  end
+
+  def send_reference_invite
+    @reference = @answer_sheet.reference_sheets.find(params[:reference_id])
+    if params[:reference]
+      reference_params = params.fetch(:reference)[@reference.id.to_s].permit(:relationship, :title, :first_name, :last_name, :phone, :email, :is_staff)
+
+      @reference.update_attributes(reference_params)
+    end
+    if @reference.valid?
+      @reference.send_invite
+    end
+  end
+
+  def submit
+    return false unless validate_sheet
+    flash[:notice] = "Your form has been submitted. Thanks!"
+    redirect_to root_path
+  end
+
+  protected
+  def answer_sheet_type
+    (params[:answer_sheet_type] || Fe.answer_sheet_class || 'AnswerSheet').constantize
+  end
+
+  def get_answer_sheet
+    @answer_sheet = answer_sheet_type.find(params[:id])
+  end
+
+  def validate_sheet
+    unless @answer_sheet.completely_filled_out?
+      @presenter = Fe::AnswerPagesPresenter.new(self, @answer_sheet, params[:a])
+      render 'incomplete'
+      return false
+    end
+    return true
+  end
+end

data/app/controllers/fe/reference_sheets_controller.rb

@@ -0,0 +1,29 @@
+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
+      render :not_found and return
+    end
+    @answer_sheet.start! if @answer_sheet.created?
+    # Set up question_sheet if needed
+    if @answer_sheet.question_sheets.empty?
+      @answer_sheet.question_sheets << Fe::QuestionSheet.find(@answer_sheet.question.related_question_sheet)
+    end
+    @presenter = Fe::AnswerPagesPresenter.new(self, @answer_sheet, params[:a])
+    @elements = @presenter.questions_for_page(:first).elements
+    @page = @presenter.pages.first
+    render 'answer_sheets/edit'
+  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
+end

data/app/helpers/fe/answer_pages_helper.rb

@@ -0,0 +1,19 @@
+module Fe::AnswerPagesHelper
+  
+  # page sidebar navigation
+  def li_page_active_if(condition, attributes = {}, &block)
+    if condition
+      attributes[:class] ||= ''
+      attributes[:class] += " active"
+    end
+    content_tag("li", attributes, &block)
+  end
+  
+  # prepares the javascript function call to load a page
+  def load_page_js(page_link)
+    return '' if page_link.nil?
+    
+    %{$.fe.pageHandler.loadPage('#{page_link.dom_id}','#{page_link.load_path}')}
+  end
+  
+end

data/app/helpers/fe/application_helper.rb

@@ -0,0 +1,49 @@
+module Fe
+  module ApplicationHelper
+    include AnswerPagesHelper
+    def pretty_tag(txt)
+      txt.to_s.gsub(/\s/, "_").gsub(/(?!-)\W/, "").downcase
+    end
+
+    def flatten_hash(hash = params, ancestor_names = [])
+      flat_hash = {}
+      hash.each do |k, v|
+        names = Array.new(ancestor_names)
+        names << k
+        if v.is_a?(Hash)
+          flat_hash.merge!(flatten_hash(v, names))
+        else
+          key = flat_hash_key(names)
+          key += "[]" if v.is_a?(Array)
+          flat_hash[key] = v
+        end
+      end
+
+      flat_hash
+    end
+
+    def flat_hash_key(names)
+      names = Array.new(names)
+      name = names.shift.to_s.dup
+      names.each do |n|
+        name << "[#{n}]"
+      end
+      name
+    end
+
+    #def calendar_date_select_tag(name, value = nil, options = {})
+    #  options.merge!({'data-calendar' => true})
+    #  text_field_tag(name, value, options )
+    #end
+
+    def tip(t)
+      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')
+    end
+
+  end
+end

data/app/mailers/fe/notifier.rb

@@ -0,0 +1,22 @@
+module Fe
+  class Notifier < ActionMailer::Base
+
+    # call Notifier.deliver_notification
+    def notification(p_recipients, p_from, template_name, template_params = {}, options = {})
+      email_template = EmailTemplate.find_by_name(template_name)
+
+      if email_template.nil?
+        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))
+        @recipients = 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)
+      end
+    end
+  end
+end

data/app/models/fe/answer.rb

@@ -0,0 +1,13 @@
+# Answer
+# - a single answer to a given question for a specific answer sheet (instance of capturing answers)
+# - there may be multiple answers to a question for "choose many" (checkboxes)
+
+# short value is indexed for finding the value (reporting)
+# essay questions have a nil short value
+# may want special handling for ChoiceFields to store both id/slug and text representations
+
+module Fe
+  class Answer < ActiveRecord::Base
+    include Fe::AnswerConcern
+  end
+end

data/app/models/fe/answer_pages_presenter.rb

@@ -0,0 +1,13 @@
+# A presenter is a class representation of a view, which consolidates data from multiple models
+# Pages editing can be initiated from 3 different controllers, AnswerSheets for the initial load, 
+#   AnswerPages to AJAX load in another page, and (in BOAT) the ApplicationsController for multiple sheets.
+# Rather than duplicate code from controller to controller, each place can simply reference this Presenter.
+
+# We always need data to render the current page for editing. 
+# On the initial load, we need data for the page list (sidebar).
+# On later page loads, we need to determine the "next page" which basically requires the page list again.
+module Fe
+  class AnswerPagesPresenter < Presenter
+    include Fe::AnswerPagesPresenterConcern
+  end
+end

data/app/models/fe/answer_sheet.rb

@@ -0,0 +1,10 @@
+module Fe
+  class AnswerSheet < ActiveRecord::Base
+    if Fe.answer_sheet_class.constantize == 'Fe::AnswerSheet'
+      self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
+    else
+      self.table_name = Fe.answer_sheet_class.constantize.table_name
+    end
+    include Fe::AnswerSheetConcern
+  end
+end