fe 0.0.3

data/app/models/fe/element.rb

@@ -0,0 +1,164 @@
+# Element represents a section, question or content element on the question sheet
+module Fe
+  class Element < ActiveRecord::Base
+    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"
+
+    belongs_to :choice_field,
+               :class_name => "Fe::ChoiceField",
+               :foreign_key => "conditional_id"
+
+    self.inheritance_column = :kind
+
+    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}) }
+
+    validates_presence_of :kind
+    validates_presence_of :style
+    # validates_presence_of :label, :style, :on => :update
+
+    validates_length_of :kind, :maximum => 40, :allow_nil => true
+    validates_length_of :style, :maximum => 40, :allow_nil => true
+    # validates_length_of :label, :maximum => 255, :allow_nil => true
+
+    before_validation :set_defaults, :on => :create
+
+    # HUMANIZED_ATTRIBUTES = {
+    #   :slug => "Variable"
+    # }changed.include?('address1')
+    #
+    # def self.human_attrib_name(attr)
+    #   HUMANIZED_ATTRIBUTES[attr.to_sym] || super
+    # end
+
+    def has_response?(answer_sheet = nil)
+      false
+    end
+
+    def limit(answer_sheet = nil)
+      if answer_sheet && object_name.present? && attribute_name.present?
+        begin
+          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
+          end
+        rescue
+          nil
+        end
+      end
+    end
+
+    def required?(answer_sheet = nil)
+      required == true
+    end
+
+    def position(page = nil)
+      if page
+        page_elements.where(:page_id => page.id).first.try(:position)
+      else
+        self[:position]
+      end
+    end
+
+    def set_position(position, page = nil)
+      if page
+        pe = page_elements.where(:page_id => page.id).first
+        pe.update_attribute(:position, position) if pe
+      else
+        self[:position] = position
+      end
+      position
+    end
+
+    def page_id(page = nil)
+      if page
+        page.id
+      else
+        pages.first.id
+      end
+    end
+
+    def question?
+      self.kind_of?(Question)
+    end
+
+
+    # by default the partial for an element matches the class name (override as necessary)
+    def ptemplate
+      self.class.to_s.underscore
+    end
+
+    # copy an item and all it's children
+    def duplicate(page, parent = nil)
+      new_element = self.class.new(self.attributes.except('id', 'created_at', 'updated_at'))
+      case parent.class.to_s
+        when Fe::ChoiceField
+          new_element.conditional_id = parent.id
+        when Fe::QuestionGrid, Fe::QuestionGridWithTotal
+          new_element.question_grid_id = parent.id
+      end
+      new_element.save(:validate => false)
+      Fe::PageElement.create(:element => new_element, :page => page) unless parent
+
+      # duplicate children
+      if respond_to?(:elements) && elements.present?
+        elements.each {|e| e.duplicate(page, new_element)}
+      end
+
+      new_element
+    end
+
+    # include nested elements
+    def all_elements
+      if respond_to?(:elements)
+        (elements + elements.collect(&:all_elements)).flatten
+      else
+        []
+      end
+    end
+
+    def reuseable?
+      (self.is_a?(Question) || self.is_a?(Fe::QuestionGrid) || self.is_a?(Fe::QuestionGridWithTotal))
+    end
+
+    def self.max_label_length
+      @@max_label_length ||= Fe::Element.columns.find{ |c| c.name == "label" }.limit
+    end
+
+    protected
+    def set_defaults
+      if self.content.blank?
+        case self.class.to_s
+          when "Fe::ChoiceField" then self.content ||= "Choice One\nChoice Two\nChoice Three"
+          when "Fe::Paragraph" then self.content ||="Lorem ipsum..."
+        end
+      end
+
+      if self.style.blank?
+        case self.class.to_s
+          when 'Fe::TextField' then self.style ||= 'essay'
+          when "Fe::DateField" then self.style ||= "date"
+          when "Fe::FileField" then self.style ||= "file"
+          when "Fe::Paragraph" then self.style ||= "paragraph"
+          when "Fe::Section" then self.style ||= "section"
+          when "Fe::ChoiceField" then self.style = "checkbox"
+          when "Fe::QuestionGrid" then self.style ||= "grid"
+          when "Fe::QuestionGridWithTotal" then self.style ||= "grid_with_total"
+          when "Fe::SchoolPicker" then self.style ||= "school_picker"
+          when "Fe::ProjectPreference" then self.style ||= "project_preference"
+          when "Fe::StateChooser" then self.style ||= "state_chooser"
+          when "Fe::ReferenceQuestion" then self.style ||= "peer"
+          else
+            self.style ||= self.class.to_s.underscore
+        end
+      end
+    end
+
+  end
+end

data/app/models/fe/email_template.rb

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

data/app/models/fe/option.rb

@@ -0,0 +1,10 @@
+module Fe
+  class Option
+    attr_reader :key
+    attr_reader :value
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+  end
+end

data/app/models/fe/option_group.rb

@@ -0,0 +1,10 @@
+module Fe
+  class OptionGroup
+    attr_reader :label
+    attr_reader :group
+    def initialize(label, group)
+      @label = label
+      @group = group
+    end
+  end
+end

data/app/models/fe/page.rb

@@ -0,0 +1,101 @@
+require 'acts_as_list'
+module Fe
+  class Page < ActiveRecord::Base
+    self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
+
+    belongs_to :question_sheet
+
+    has_many :page_elements, -> { order(:position) },
+             :dependent => :destroy
+
+    has_many :elements, -> { order(Fe::PageElement.table_name + '.position') },
+             :through => :page_elements
+
+    has_many :question_grid_with_totals, -> { where("kind = 'Fe::QuestionGridWithTotal'") },
+             :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 :question_grids, -> { where("kind = 'Fe::QuestionGrid'") },
+             :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
+
+    acts_as_list :column => :number, :scope => :question_sheet_id
+
+    scope :visible, -> { where(:hidden => false) }
+
+    # callbacks
+    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_uniqueness_of :number, :scope => :question_sheet_id
+
+    validates_numericality_of :number, :only_integer => true
+
+    # 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
+    # def active?
+    #   # find first condition that doesn't pass (nil if all pass)
+    #   self.conditions.detect { |c| !c.evaluate? }.nil?  # true if all pass
+    # end
+    #
+    # def question?
+    #   false
+    # end
+
+    def questions_before_position(position)
+      self.elements.where(["#{Fe::PageElement.table_name}.position < ?", position])
+    end
+
+    # Include nested elements
+    def all_elements
+      (elements + elements.collect(&:all_elements)).flatten
+    end
+
+    def copy_to(question_sheet)
+      new_page = Fe::Page.new(self.attributes)
+      new_page.question_sheet_id = question_sheet.id
+      new_page.save(:validate => false)
+      self.elements.each do |element|
+        if !question_sheet.archived? && element.reuseable?
+          Fe::PageElement.create(:element => element, :page => new_page)
+        else
+          element.duplicate(new_page)
+        end
+      end
+    end
+
+    def complete?(answer_sheet)
+      all_elements.all? {|e| !e.required?(answer_sheet) || e.has_response?(answer_sheet)}
+    end
+
+    def started?(answer_sheet)
+      all_elements.any? {|e| e.has_response?(answer_sheet)}
+    end
+
+    def has_questions?
+      all_elements.any? {|e| e.is_a?(Question)}
+    end
+
+    private
+
+    # next unused label with "Page" prefix
+    def set_default_label
+      self.label = Fe.next_label("Page", Fe::Page.untitled_labels(self.question_sheet)) if self.label.blank?
+    end
+
+    def self.untitled_labels(sheet)
+      sheet ? sheet.pages.where("label like 'Page %'").map {|p| p.label} : []
+    end
+
+  end
+end

data/app/models/fe/page_element.rb

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

data/app/models/fe/page_link.rb

@@ -0,0 +1,15 @@
+# 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 :save_path  # to save current page
+
+    def initialize(label, load_path, dom_id, page)
+      @label = label
+      @load_path = load_path
+      @dom_id = dom_id
+      @page = page
+    end
+
+  end
+end

data/app/models/fe/paragraph.rb

@@ -0,0 +1,10 @@
+# Paragraph
+# - Represents a block of content
+#
+# :kind         - 'Fe::Paragraph' for single table inheritance (STI)
+# :content      - instructions, agreements, etc. to display
+module Fe
+  class Paragraph < Element
+    validates_presence_of :content, :on => :update
+  end
+end

data/app/models/fe/payment.rb

@@ -0,0 +1,52 @@
+module Fe
+  class Payment < ActiveRecord::Base
+    self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
+
+    attr_accessor :first_name, :last_name, :address, :city, :state, :zip, :card_number, :payment_type,
+                  :expiration_month, :expiration_year, :security_code, :staff_first, :staff_last, :card_type
+
+    scope :non_denied, -> { where("(status <> 'Denied' AND status <> 'Errored') OR status is null") }
+
+    belongs_to :answer_sheet, class_name: Fe.answer_sheet_class
+
+    after_save :check_answer_sheet_complete
+
+    def validate
+      if credit?
+        errors.add_on_empty([:first_name, :last_name, :address, :city, :state, :zip, :card_number,
+                             :expiration_month, :expiration_year, :security_code])
+        errors.add(:card_number, "is invalid.") if get_card_type.nil?
+      end
+    end
+
+    def check_answer_sheet_complete
+      if self.approved?
+        self.answer_sheet.complete
+      end
+    end
+
+    def credit?
+      self.payment_type == 'Credit Card'
+    end
+
+    def staff?
+      self.payment_type == 'Staff'
+    end
+
+    def approved?
+      self.status == 'Approved'
+    end
+
+    def approve!
+      self.status = 'Approved'
+      self.save!
+    end
+
+    def get_card_type
+      card =  ActiveMerchant::Billing::CreditCard.new(:number => card_number)
+      card.valid?
+      card.type
+    end
+  end
+
+end

data/app/models/fe/payment_question.rb

@@ -0,0 +1,22 @@
+module Fe
+  class PaymentQuestion < Question
+
+    def response(answer_sheet=nil)
+      return Payment.new unless answer_sheet
+      answer_sheet.payments || [Payment.new(:answer_sheetlication_id => answer_sheet.id) ]
+    end
+
+    def display_response(answer_sheet=nil)
+      response(answer_sheet).to_s
+    end
+
+    def has_response?(answer_sheet = nil)
+      if answer_sheet
+        answer_sheet.payments.length > 0
+      else
+        false
+      end
+    end
+
+  end
+end

data/app/models/fe/presenter.rb

@@ -0,0 +1,23 @@
+# based on http://blog.caboo.se/articles/2007/8/23/simple-presenters
+module Fe
+  class Presenter
+    include ActionView::Helpers::TagHelper # link_to
+    # include ActionView::Helpers::UrlHelper # url_for
+    include ActionController::UrlFor # named routes
+    include ActionController::RecordIdentifier # dom_id
+    include Rails.application.routes.url_helpers
+    attr_accessor :controller # so we can be lazy
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def request
+      @controller.request
+    end
+
+    def env
+      @controller.env
+    end
+  end
+end

data/app/models/fe/question.rb

@@ -0,0 +1,256 @@
+# Question
+# - An individual question element
+# - children: TextField, ChoiceField, DateField, FileField
+
+# :kind         - 'TextField', 'ChoiceField', 'DateField' for single table inheritance (STI)
+# :label        - label for the question, such as "First name"
+# :style        - essay|phone|email|numeric|currency|simple, selectbox|radio, checkbox, my|mdy
+# :required     - is this question itself required or optional?
+# :content      - choices (one per line) for choice field
+
+module Fe
+  class Question < Element
+    include ActionController::RecordIdentifier # dom_id
+    has_many :conditions,
+             :class_name => "Condition",
+             :foreign_key => "toggle_id",
+             :dependent => :nullify
+
+    has_many :dependents,
+             :class_name => "Condition",
+             :foreign_key => "trigger_id",
+             :dependent => :nullify
+
+    has_many :sheet_answers,
+             :class_name => "Answer",
+             :foreign_key => "question_id",
+             :dependent => :destroy
+
+    belongs_to :related_question_sheet,
+               :class_name => "QuestionSheet",
+               :foreign_key => "related_question_sheet_id"
+
+    # 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.'
+
+    # 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
+    # however, "Choose Many" (checkbox) questions have multiple answers in a single response
+
+    attr_accessor :answers
+
+    # @answers = nil            # one or more answers in response to this question
+    # @mark_for_destroy = nil   # when something is unchecked, there are less answers to the question than before
+
+
+    # a question 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
+    # def active?
+    #   # find first condition that doesn't pass (nil if all pass)
+    #   self.conditions.find(:all).find { |c| !c.evaluate? }.nil?  # true if all pass
+    # end
+
+    # def conditions_attributes=(new_conditions)
+    #   conditions.collect(&:destroy)
+    #   conditions.reload
+    #   (0..(new_conditions.length - 1)).each do |i|
+    #     i = i.to_s
+    #     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)
+    #     end
+    #   end
+    # end
+
+    # element view provides the element label with required indicator
+    def default_label?
+      true
+    end
+
+    def locked?(params, answer_sheet, presenter)
+      return true unless params['controller'] == 'answer_pages' && 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
+      elsif self.object_name == 'person.emergency_address' && ['address1','address2','city','zip','email','state','country','contactName','homePhone','workPhone'].include?(self.attribute_name)
+        # Emergency Contact
+        return false
+      elsif self.label == 'Relationship To You' || self.style == "country" || (self.style == "email" && self.label == "Confirm Email")
+        # Relationship & Country & Email Address
+        return false
+      else
+        return answer_sheet.frozen? && !presenter.reference?
+      end
+    end
+
+    # css class names for javascript-based validation
+    def validation_class(answer_sheet = nil)
+      if required?(answer_sheet)
+        ' required '
+      else
+        ''
+      end
+    end
+
+    # just in case something slips through client-side validation?
+    # def valid_response?
+    #   if self.required? && !self.has_response? then
+    #     false
+    #   else
+    #     # other validations
+    #     true
+    #   end
+    # end
+
+    # just in case something slips through client-side validation?
+    # def valid_response_for_answer_sheet?(answers)
+    #    return true if !self.required?
+    #    answer  = answers.detect {|a| a.question_id == self.id}
+    #    return answer && answer.value.present?
+    #    # raise answer.inspect
+    #  end
+
+    # shortcut to return first answer
+    def response(answer_sheet)
+      responses(answer_sheet).first.to_s
+    end
+
+    def display_response(answer_sheet)
+      r = responses(answer_sheet)
+      if r.blank?
+        ""
+      else
+        r.join(", ")
+      end
+    end
+
+    def responses(answer_sheet)
+      return [] unless answer_sheet
+
+      # try to find answer from external object
+      if !object_name.blank? and !attribute_name.blank?
+        obj = object_name == 'answer_sheet' ? answer_sheet : eval("answer_sheet." + object_name)
+        if obj.nil? or eval("obj." + attribute_name + ".nil?")
+          []
+        else
+          [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)
+      end
+    end
+
+    # set answers from posted response
+    def set_response(values, answer_sheet)
+      values = Array.wrap(values)
+      if !object_name.blank? and !attribute_name.blank?
+        # if eval("answer_sheet." + object_name).present?
+        object = object_name == 'answer_sheet' ? answer_sheet : eval("answer_sheet." + object_name)
+        unless object.present?
+          if object_name.include?('.')
+            objects = object_name.split('.')
+            object = eval("answer_sheet." + objects[0..-2].join('.') + ".create_" + objects.last)
+            eval("answer_sheet." + objects[0..-2].join('.')).reload
+          end
+        end
+        unless responses(answer_sheet) == values
+          value = values.first
+          if self.is_a?(Fe::DateField) && value.present?
+            begin
+              value = Date.strptime(value, (I18n.t 'date.formats.default'))
+            rescue
+              raise "invalid date - " + value.inspect
+            end
+          end
+          object.update_attribute(attribute_name, value)
+        end
+        # else
+        #   raise object_name.inspect + ' == ' + attribute_name.inspect
+        # end
+      else
+        @answers ||= []
+        @mark_for_destroy ||= []
+        # go through existing answers (in reverse order, as we delete)
+        (@answers.length - 1).downto(0) do |index|
+          # reject: skip over responses that are unchanged
+          unless values.reject! {|value| value == @answers[index]}
+            # remove any answers that don't match the posted values
+            @mark_for_destroy << @answers[index]   # destroy from database later
+            @answers.delete_at(index)
+          end
+        end
+
+        # insert any new answers
+        for value in values
+          if @mark_for_destroy.empty?
+            answer = Fe::Answer.new(:question_id => self.id)
+          else
+            # re-use marked answers (an update vs. a delete+insert)
+            answer = @mark_for_destroy.pop
+          end
+          answer.set(value)
+          @answers << answer
+        end
+      end
+    end
+
+    def save_file(answer_sheet, file)
+      @answers.collect(&:destroy) if @answers
+      Fe::Answer.create!(:question_id => self.id, :answer_sheet_id => answer_sheet.id, :attachment => file)
+    end
+
+    # save this question's @answers to database
+    def save_response(answer_sheet)
+      unless @answers.nil?
+        for answer in @answers
+          if answer.is_a?(Fe::Answer)
+            answer.answer_sheet_id = answer_sheet.id
+            answer.save!
+          end
+        end
+      end
+
+      # remove others
+      unless @mark_for_destroy.nil?
+        for answer in @mark_for_destroy
+          answer.destroy
+        end
+        @mark_for_destroy.clear
+      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
+      return false if answers.length == 0
+      answers.each do |answer|   # loop through Answers
+        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 || (answer_sheet && choice_field && choice_field.has_answer?('1', answer_sheet))
+    end
+
+  end
+end