jakewendt-surveyor 0.11.3

data/app/helpers/survey_form_builder.rb

@@ -0,0 +1,37 @@
+class SurveyFormBuilder < ActionView::Helpers::FormBuilder 
+  def survey_check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+    fields = @template.survey_check_box(@object_name, method, options.merge(:object => @object), checked_value, unchecked_value)
+    fields[1]
+  end
+end
+
+module ActionView
+  module Helpers
+    module FormHelper
+      def survey_check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
+        if (Rails::VERSION::STRING.to_f > 2.1)
+          InstanceTag.new(object_name, method, self, options.delete(:object)).to_survey_check_box_tag(options, checked_value, unchecked_value)
+        else
+          InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_survey_check_box_tag(options, checked_value, unchecked_value)
+        end
+      end
+    end
+
+    class InstanceTag
+      def to_survey_check_box_tag(options = {}, checked_value = "1", unchecked_value = "0")
+        options = options.stringify_keys
+        options["type"]     = "checkbox"
+        options["value"]    = checked_value
+        if options.has_key?("checked")
+          cv = options.delete "checked"
+          checked = cv == true || cv == "checked"
+        else
+          checked = self.class.check_box_checked?(value(object), checked_value)
+        end
+        options["checked"] = "checked" if checked
+        add_default_name_and_id(options)
+        [tag("input", "name" => options["name"], "type" => "hidden", "value" => unchecked_value), tag("input", options)]
+      end
+    end
+  end
+end

data/app/helpers/surveyor_helper.rb

@@ -0,0 +1,67 @@
+module SurveyorHelper
+
+  # Extending surveyor
+  include SurveyorHelperExtensions if Surveyor::Config['extend'].include?("surveyor_helper")
+    
+  # Configuration
+  def surveyor_config
+    Surveyor::Config
+  end
+  
+  # Layout: stylsheets and javascripts
+  def surveyor_includes
+    surveyor_stylsheets + surveyor_javascripts    
+  end
+  def surveyor_stylsheets
+    stylesheet_link_tag 'surveyor/reset', 'surveyor/surveyor', 'surveyor/ui.theme.css','surveyor/jquery-ui-slider-additions'
+  end
+  def surveyor_javascripts
+    javascript_include_tag 'surveyor/jquery-1.2.6.js', 'surveyor/jquery-ui-personalized-1.5.3.js', 'surveyor/accessibleUISlider.jQuery.js','surveyor/jquery.form.js', 'surveyor/surveyor.js'
+  end
+  
+  # Section: dependencies, menu, previous and next
+  def dependency_explanation_helper(question,response_set)
+    # Attempts to explain why this dependent question needs to be answered by referenced the dependent question and users response
+    trigger_responses = []
+    dependent_questions = Question.find_all_by_id(question.dependency.dependency_conditions.map(&:question_id)).uniq
+    response_set.responses.find_all_by_question_id(dependent_questions.map(&:id)).uniq.each do |resp|
+      trigger_responses << resp.to_s
+    end
+    "&nbsp;&nbsp;You answered &quot;#{trigger_responses.join("&quot; and &quot;")}&quot; to the question &quot;#{dependent_questions.map(&:text).join("&quot;,&quot;")}&quot;"
+  end
+  def menu_button_for(section)
+    submit_tag(section.title, :name => "section[#{section.id}]")
+  end
+  def previous_section
+    # submit_tag("&laquo; Previous section", :name => "section[#{@section.previous.id}]") unless @section.previous.nil?
+    # refactored to use copy in memory instead of making extra db calls
+    submit_tag("&laquo; Previous section", :name => "section[#{@sections[@sections.index(@section)-1].id}]") unless @sections.first == @section
+  end
+  def next_section
+    # @section.next.nil? ? submit_tag("Click here to finish", :name => "finish") : submit_tag("Next section &raquo;", :name => "section[#{@section.next.id}]")
+    # refactored to use copy in memory instead of making extra db calls
+    @sections.last == @section ? submit_tag("Click here to finish", :name => "finish") : submit_tag("Next section &raquo;", :name => "section[#{@sections[@sections.index(@section)+1].id}]")
+  end
+  
+  # Questions
+  def next_number
+    @n ||= 0
+    "#{@n += 1}<span style='padding-left:0.1em;'>)</span>"
+  end
+  def split_text(text = "") # Split text into with "|" delimiter - parts to go before/after input element
+    {:prefix => text.split("|")[0].blank? ? "&nbsp;" : text.split("|")[0], :postfix => text.split("|")[1] || "&nbsp;"}
+  end
+  def question_help_helper(question)
+    question.help_text.blank? ? "" : %Q(<span class="question-help">#{question.help_text}</span>)
+  end
+
+  # Answers
+  def fields_for_response(response, response_group = nil, &block)
+    name = response_group.nil? ? "responses[#{response.question_id}][#{response.answer_id}]" : "response_groups[#{response.question_id}][#{response_group}][#{response.answer_id}]"
+    fields_for(name, response, :builder => SurveyFormBuilder, &block)
+  end
+  def fields_for_radio(response, &block)
+    fields_for("responses[#{response.question_id}]", response, :builder => SurveyFormBuilder, &block)
+  end
+  
+end

data/app/models/answer.rb

@@ -0,0 +1,23 @@
+class Answer < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+  
+  # Associations
+  belongs_to :question
+  has_many :responses
+
+  # Scopes
+  default_scope :order => "display_order ASC"
+  
+  # Validations
+  validates_presence_of :text
+  validates_numericality_of :question_id, :allow_nil => false, :only_integer => true
+  
+  # Methods
+  def renderer(q = question)  
+    r = [q.pick.to_s, self.response_class].compact.map(&:downcase).join("_")
+    r.blank? ? :default : r.to_sym
+  end
+  
+end

data/app/models/dependency.rb

@@ -0,0 +1,50 @@
+class Dependency < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+
+  # Associations
+  belongs_to :question
+  belongs_to :question_group
+  has_many :dependency_conditions
+  
+  # Validations
+  validates_presence_of :rule
+  validates_format_of :rule, :with => /^(?:and|or|\)|\(|[A-Z]|\s)+$/ #TODO properly formed parenthesis etc.
+  validates_numericality_of :question_id, :if => Proc.new { |d| d.question_group_id.nil? }
+  validates_numericality_of :question_group_id, :if => Proc.new { |d| d.question_id.nil? }
+  
+  # Attribute aliases
+  alias_attribute :dependent_question_id, :question_id
+  
+  def question_group_id=(i)
+    write_attribute(:question_id, nil) unless i.nil?
+    write_attribute(:question_group_id, i)
+  end
+  
+  def question_id=(i)
+    write_attribute(:question_group_id, nil) unless i.nil?
+    write_attribute(:question_id, i) 
+  end
+  
+  # Has this dependency has been met in the context of response_set?
+  # Substitutes the conditions hash into the rule and evaluates it
+  def is_met?(response_set)
+    ch = conditions_hash(response_set)
+    return false if ch.blank?
+    # logger.debug "rule: #{self.rule.inspect}"
+    # logger.debug "rexp: #{rgx.inspect}"
+    # logger.debug "keyp: #{ch.inspect}"
+    # logger.debug "subd: #{self.rule.gsub(rgx){|m| ch[m.to_sym]}}"
+    rgx = Regexp.new(self.dependency_conditions.map{|dc| ["a","o"].include?(dc.rule_key) ? "#{dc.rule_key}(?!nd|r)" : dc.rule_key}.join("|")) # exclude and, or
+    eval(self.rule.gsub(rgx){|m| ch[m.to_sym]})
+  end
+  
+  # A hash of the conditions (keyed by rule_key) and their evaluation (boolean) in the context of response_set
+  def conditions_hash(response_set)
+    hash = {}
+    self.dependency_conditions.each{|dc| hash.merge!(dc.to_hash(response_set))}
+    return hash
+  end
+  
+end

data/app/models/dependency_condition.rb

@@ -0,0 +1,47 @@
+class DependencyCondition < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+
+  # Constants
+  OPERATORS = %w(== != < > <= >=) # CONSTANT or @@class_variable when validations listed before class method
+
+  # Associations
+  belongs_to :answer
+  belongs_to :dependency
+  belongs_to :dependent_question, :foreign_key => :question_id, :class_name => :question
+  belongs_to :question
+
+  # Validations
+  validates_numericality_of :dependency_id, :question_id, :answer_id
+  validates_presence_of :operator, :rule_key
+  validates_inclusion_of :operator, :in => OPERATORS
+  validates_uniqueness_of :rule_key, :scope => :dependency_id
+
+  acts_as_response # includes "as" instance method
+  
+  # Class methods
+  def self.operators
+    OPERATORS
+  end
+
+  # Instance methods
+  def to_hash(response_set)
+    response = response_set.responses.detect{|r| r.answer_id.to_i == self.answer_id.to_i} || false # eval("nil and false") => nil so return false if no response is found
+    {rule_key.to_sym => (response and self.is_met?(response))}
+  end
+
+  # Checks to see if the response passed in meets the dependency condition
+  def is_met?(response)
+    klass = response.answer.response_class
+    return case self.operator
+    when "==", "<", ">", "<=", ">="
+      response.as(klass).send(self.operator, self.as(klass))
+    when "!="
+      !(response.as(klass) == self.as(klass))
+    else
+      false
+    end
+  end
+
+end

data/app/models/question.rb

@@ -0,0 +1,54 @@
+class Question < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+    
+  # Associations
+  belongs_to :survey_section
+  belongs_to :question_group
+  has_many :answers, :order => "display_order ASC" # it might not always have answers
+  has_one :dependency
+
+  # Scopes
+  default_scope :order => "display_order ASC"
+  
+  # Validations
+  validates_presence_of :text, :survey_section_id, :display_order
+  validates_inclusion_of :is_mandatory, :in => [true, false]
+  
+  # Instance Methods
+  def initialize(*args)
+    super(*args)
+    default_args
+  end
+  
+  def default_args
+    self.is_mandatory ||= true
+    self.display_type ||= "default"
+    self.pick ||= "none"
+  end
+  
+  def mandatory?
+    self.is_mandatory == true
+  end
+  
+  def dependent?
+    self.dependency != nil
+  end
+  def triggered?(response_set)
+    dependent? ? self.dependency.is_met?(response_set) : true
+  end
+  def css_class(response_set)
+    [(dependent? ? "dependent" : nil), (triggered?(response_set) ? nil : "hidden"), custom_class].compact.join(" ")
+  end
+  
+  def part_of_group?
+    !self.question_group.nil?
+  end
+
+  def renderer(g = question_group)
+    r = [g ? g.renderer.to_s : nil, display_type].compact.join("_")
+    r.blank? ? :default : r.to_sym
+  end
+  
+end

data/app/models/question_group.rb

@@ -0,0 +1,33 @@
+class QuestionGroup < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+    
+  has_many :questions
+  has_one :dependency
+  
+  # Instance Methods
+  def initialize(*args)
+    super(*args)
+    default_args
+  end
+  
+  def default_args
+    self.display_type ||= "inline"
+  end
+
+  def renderer
+    display_type.blank? ? :default : display_type.to_sym
+  end
+  
+  def dependent?
+    self.dependency != nil
+  end
+  def triggered?(response_set)
+    dependent? ? self.dependency.is_met?(response_set) : true
+  end
+  def css_class(response_set)
+    [(dependent? ? "dependent" : nil), (triggered?(response_set) ? nil : "hidden"), custom_class].compact.join(" ")
+  end
+  
+end

data/app/models/response.rb

@@ -0,0 +1,94 @@
+class Response < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+  
+  include ActionView::Helpers::SanitizeHelper
+         
+  # Associations
+  belongs_to :response_set
+  belongs_to :question
+  belongs_to :answer
+  
+  # Validations
+  validates_presence_of :response_set_id, :question_id, :answer_id
+      
+  acts_as_response # includes "as" instance method
+
+  def selected
+    !self.new_record?
+  end
+  
+  alias_method :selected?, :selected
+  
+  def selected=(value)
+    true
+  end
+  
+  def correct?
+    question.correct_answer_id.nil? or self.answer.response_class != "answer" or (question.correct_answer_id.to_i == answer_id.to_i)
+  end
+  
+  def to_s # used in dependency_explanation_helper
+    if self.answer.response_class == "answer" and self.answer_id
+      return self.answer.text
+    else
+      return "#{(self.string_value || self.text_value || self.integer_value || self.float_value || nil).to_s}"
+    end
+  end
+  
+
+		#	Error for when answer's response_class is not in
+		#	( answer string integer float text date time datetime )
+		#	Actually, date and time aren't available anymore.
+		class InvalidResponseClass < StandardError	#:nodoc:
+		end
+
+		#	Return an individual response's question and
+		#	answer coded for Home Exposure questionnaire.
+		def q_and_a_codes
+			q_code = self.question.data_export_identifier
+
+			unless %w( answer string integer float
+					text datetime
+				).include?(self.answer.response_class)
+				raise InvalidResponseClass
+			end
+
+			a_code = if self.answer.response_class == "answer"
+				self.answer.data_export_identifier
+			else
+				self.send("#{self.answer.response_class}_value")
+			end
+			[ q_code, a_code ]
+		end
+
+		def q_and_a_codes_and_text
+			q_code = self.question.data_export_identifier
+
+			unless %w( answer string integer float
+					text datetime
+				).include?(self.answer.response_class)
+				raise InvalidResponseClass
+			end
+
+			a_code = if self.answer.response_class == "answer"
+				self.answer.data_export_identifier
+			else
+				self.send("#{self.answer.response_class}_value")
+			end
+
+			a_text = if self.answer.response_class == "answer"
+				self.answer.text
+			else
+				self.send("#{self.answer.response_class}_value")
+			end
+
+			q_text = self.question.text
+
+			{ q_code => { :a_code => a_code, :a_text => a_text, :q_text => q_text }}
+		end
+		alias_method :codes_and_text, :q_and_a_codes_and_text
+		
+
+end

data/app/models/response_set.rb

@@ -0,0 +1,316 @@
+class ResponseSet < ActiveRecord::Base
+
+  # Extending surveyor
+  include "#{self.name}Extensions".constantize if Surveyor::Config['extend'].include?(self.name.underscore)
+  
+  # Associations
+  belongs_to :survey
+  belongs_to :user
+  has_many :responses, :dependent => :destroy
+  
+  # Validations
+  validates_presence_of :survey_id
+  validates_associated :responses
+  validates_uniqueness_of :access_code
+  
+  # Attributes
+  attr_protected :completed_at
+  attr_accessor :current_section_id
+
+  # Callbacks
+  after_update :save_responses
+  
+  # Instance methods
+  def initialize(*args)
+    super(*args)
+    default_args
+  end
+  
+  def default_args
+    self.started_at ||= Time.now
+    self.access_code = Surveyor.make_tiny_code
+  end
+  
+  def access_code=(val)
+    while ResponseSet.find_by_access_code(val)
+      val = Surveyor.make_tiny_code
+    end
+    super
+  end
+  
+  def to_csv
+    qcols = Question.content_columns.map(&:name) - %w(created_at updated_at)
+    acols = Answer.content_columns.map(&:name) - %w(created_at updated_at)
+    rcols = Response.content_columns.map(&:name)
+    require 'fastercsv'
+    FCSV(result = "") do |csv|
+      csv << qcols.map{|qcol| "question.#{qcol}"} + acols.map{|acol| "answer.#{acol}"} + rcols.map{|rcol| "response.#{rcol}"}
+      responses.each do |response|
+        csv << qcols.map{|qcol| response.question.send(qcol)} + acols.map{|acol| response.answer.send(acol)} + rcols.map{|rcol| response.send(rcol)}
+      end
+    end
+    result
+  end
+  
+  def response_for(question_id, answer_id, group = nil)
+    found = responses.detect{|r| r.question_id == question_id && r.answer_id == answer_id && r.response_group.to_s == group.to_s}
+    found.blank? ? responses.new(:question_id => question_id, :answer_id => answer_id, :response_group => group) : found
+  end
+  
+  def clear_responses
+    question_ids = Question.find_all_by_survey_section_id(current_section_id).map(&:id)
+    responses.select{|r| question_ids.include? r.question_id}.map(&:destroy)
+    responses.reload
+  end
+  
+  def response_attributes=(response_attributes)
+    response_attributes.each do |question_id, responses_hash|
+      # Response.delete_all(["response_set_id =? AND question_id =?", self.id, question_id])
+      if (answer_id = responses_hash[:answer_id]) 
+        if (!responses_hash[:answer_id].empty?) # Dropdowns return answer id but have an empty value if they are not set... ignoring those.
+          #radio or dropdown - only one response
+          responses.build({:question_id => question_id, :answer_id => answer_id}.merge(responses_hash[answer_id] || {}))
+        end
+      else
+        #possibly multiples responses - unresponded radios end up here too
+        # we use the variable question_id, not the "question_id" in the response_hash
+        responses_hash.delete_if{|k,v| k == "question_id"}.each do |answer_id, response_hash|
+          unless response_hash.delete_if{|k,v| v.blank?}.empty?
+            responses.build({:question_id => question_id, :answer_id => answer_id}.merge(response_hash))
+          end
+        end
+      end
+    end
+  end
+
+  def response_group_attributes=(response_attributes)
+    response_attributes.each do |question_id, responses_group_hash|
+      # Response.delete_all(["response_set_id =? AND question_id =?", self.id, question_id])
+      responses_group_hash.each do |response_group_number, group_hash|
+        if (answer_id = group_hash[:answer_id]) # if group_hash has an answer_id key we treat it differently 
+          if (!group_hash[:answer_id].empty?) # dropdowns return empty values in answer_ids if they are not selected
+            #radio or dropdown - only one response
+            responses.build({:question_id => question_id, :answer_id => answer_id, :response_group => response_group_number}.merge(group_hash[answer_id] || {}))
+          end
+        else
+          #possibly multiples responses - unresponded radios end up here too
+          # we use the variable question_id in the key, not the "question_id" in the response_hash... same with response_group key
+          group_hash.delete_if{|k,v| (k == "question_id") or (k == "response_group")}.each do |answer_id, inner_hash|
+            unless inner_hash.delete_if{|k,v| v.blank?}.empty?
+              responses.build({:question_id => question_id, :answer_id => answer_id, :response_group => response_group_number}.merge(inner_hash))
+            end
+          end
+        end
+        
+      end
+    end
+  end
+  
+  def save_responses
+    responses.each{|response| response.save(false)}
+  end
+
+  def complete!
+    self.completed_at = Time.now
+  end
+  
+  def correct?
+    responses.all?(&:correct?)
+  end
+  def correctness_hash
+    { :questions => survey.sections_with_questions.map(&:questions).flatten.compact.size,
+      :responses => responses.compact.size,
+      :correct => responses.find_all(&:correct?).compact.size
+    }
+  end
+  def mandatory_questions_complete?
+    progress_hash[:triggered_mandatory] == progress_hash[:triggered_mandatory_completed]
+  end
+  def progress_hash
+    qs = survey.sections_with_questions.map(&:questions).flatten
+    ds = dependencies(qs.map(&:id))
+    triggered = qs - ds.select{|d| !d.is_met?(self)}.map(&:question)
+    { :questions => qs.compact.size,
+      :triggered => triggered.compact.size,
+      :triggered_mandatory => triggered.select{|q| q.mandatory?}.compact.size,
+      :triggered_mandatory_completed => triggered.select{|q| q.mandatory? and is_answered?(q)}.compact.size
+    }
+  end
+  def is_answered?(question)
+    %w(label image).include?(question.display_type) or !is_unanswered?(question)
+  end
+  def is_unanswered?(question)
+    self.responses.detect{|r| r.question_id == question.id}.nil?
+  end
+    
+  # Returns the number of response groups (count of group responses enterted) for this question group
+  def count_group_responses(questions)
+    questions.map{|q| responses.select{|r| (r.question_id.to_i == q.id.to_i) && !r.response_group.nil?}.group_by(&:response_group).size }.max
+  end
+  
+  def unanswered_dependencies
+    dependencies.select{|d| d.is_met?(self) and self.is_unanswered?(d.question)}.map(&:question)
+  end
+  
+
+  # Why return nil, when you can return a real value.
+  # This is untested so there may be some consequences.
+  # I only had it for use in the console.  Commenting.
+#  def current_section_id
+#    # Do all surveys have a first section???
+#    @current_section_id || self.survey.sections.first.id
+#  end
+
+  def all_validations
+    arr = validations.partition{|v| v.is_valid?(self) }
+    { :valid   => arr[0].map{|v| "question_#{v.answer.question_id}"},
+      :invalid => arr[1].map{|v| "question_#{v.answer.question_id}"} }
+  end
+
+  def all_things_hash
+    self.all_dependencies.merge(self.all_validations)
+  end
+
+  def all_dependencies
+    arr = dependencies.partition{|d| d.is_met?(self) }
+    {:show => arr[0].map{|d| d.question_group_id.nil? ? "question_#{d.question_id}" : "question_group_#{d.question_group_id}"}, :hide => arr[1].map{|d| d.question_group_id.nil? ? "question_#{d.question_id}" : "question_group_#{d.question_group_id}"}}
+  end
+
+
+
+		#	Collect all of the question and answers coded for
+		#	the Home Exposures questionnaire.
+		#
+		#		>> ResponseSet.last.q_and_a_codes
+		#
+		#		=> [["how_often_vacuumed_12mos", "1"], 
+		#		["freq_grilled_meat_outside_12mos", "2"], 
+		#		["other_pest_community_sprayed", "dogs"], 
+		#		["year_home_built", 1900], 
+		#		["number_of_rooms_in_home", 5]]
+		def q_and_a_codes
+			self.responses.collect(&:q_and_a_codes)
+		end
+		
+		#	Collect all of the question and answers coded for
+		#	the Home Exposures questionnaire.
+		#
+		#		>> ResponseSet.last.q_and_a_codes_as_attributes
+		#
+		#		=> {"doneness_of_meat_exterior_12mos"=>"3", 
+		#		"number_of_rooms_in_home"=>5, 
+		#		"year_home_built"=>1900, 
+		#		"cmty_sprayed_other_pest_12mos"=>"1", 
+		#		"other_pest_community_sprayed"=>"dogs"}
+		#
+		#		>> HomeExposureResponse.create(
+		#		ResponseSet.find(7).q_and_a_codes_as_attributes)
+		def q_and_a_codes_as_attributes
+			Hash[*self.responses.collect(&:q_and_a_codes).flatten]
+		end
+
+		#	Return a good chunk of info used when merging
+		#	response sets into one home exposure response
+		def q_and_a_codes_and_text_as_attributes
+			h=Hash.new({:a_code => '', :a_text => '(no answer)', :q_text => ''})
+			#	h.merge keeps h's defaults!!!  woohoo!
+			h.merge(self.responses.collect(&:codes_and_text).inject(:merge)||{})
+		end
+		alias_method :codes_and_text, :q_and_a_codes_and_text_as_attributes
+
+		#	Compare the Q and A codes of 2 response sets
+		#	and return boolean.
+		def is_the_same_as?(another_response_set)
+			ars = ResponseSet.find(another_response_set)
+			(self.q_and_a_codes_as_attributes.diff(
+				ars.q_and_a_codes_as_attributes)).blank?
+		end
+
+		#	Compare the Q and A codes of 2 response sets
+		#	and return hash of differences.
+		def diff(another_response_set)
+			ars = ResponseSet.find(another_response_set)
+			self.q_and_a_codes_as_attributes.diff(ars.q_and_a_codes_as_attributes)
+		end
+
+		def is_complete?
+			#	eventually return the is_complete column value
+#			false
+			!self.completed_at.nil?
+		end
+
+
+
+
+  
+  protected
+  
+  def validations(question_ids = nil)
+    question_ids ||= Question.find_all_by_survey_section_id(
+      current_section_id).map(&:id)
+    answer_ids = Answer.all(
+      :conditions => {:question_id => question_ids }).map(&:id)
+    Validation.all(:conditions => {:answer_id => answer_ids}, 
+      :include => :validation_conditions)
+  end
+
+  def dependencies(question_ids = nil)
+    question_ids ||= Question.find_all_by_survey_section_id(current_section_id).map(&:id)
+    depdendecy_ids = DependencyCondition.all(:conditions => {:question_id => question_ids}).map(&:dependency_id)
+    Dependency.find(depdendecy_ids, :include => :dependency_conditions)
+  end
+  
+end
+
+# responses
+
+# "responses"=>{
+#string   "6"=>{"question_id"=>"6", "20"=>{"string_value"=>"saf"}}, 
+#text   "7"=>{"question_id"=>"7", "21"=>{"text_value"=>""}}, 
+#radio+txt   "1"=>{"question_id"=>"1", "answer_id"=>"1", "4"=>{"string_value"=>""}}, 
+#radio   "2"=>{"answer_id"=>"6"}, 
+#radio   "3"=>{"answer_id"=>"10"}, 
+#check   "4"=>{"question_id"=>"4", "answer_id"=>"15"}, 
+#check+txt   "5"=>{"question_id"=>"5", "16"=>{"selected"=>"1"}, "19"=>{"string_value"=>""}}
+#   },
+# "survey_code"=>"test_survey", 
+# "commit"=>"Next Section (Utensiles and you!) >>", 
+# "authenticity_token"=>"8bee21081eea820ab1c658358c0baaa2e46de5d1", 
+# "_method"=>"put", 
+# "action"=>"update", 
+# "controller"=>"app", 
+# "response_set_code"=>"T2x8HhCQej", 
+# "section"=>"2"
+
+# response groups
+
+# "24"=>{
+#   "0"=>{"response_group"=>"0", "question_id"=>"24", "answer_id"=>"172"}, "1"=>{"response_group"=>"1", "question_id"=>"24", "answer_id"=>"173"}, 
+#   "2"=>{"response_group"=>"2", "question_id"=>"24", "answer_id"=>""}, "3"=>{"response_group"=>"3", "question_id"=>"24", "answer_id"=>""}, 
+#   "4"=>{"response_group"=>"4", "question_id"=>"24", "answer_id"=>""}},
+#  where "24" is the question id
+
+# Some other examples:
+# "25"=>{
+# "0"=>{"response_group"=>"0", "question_id"=>"25", "179"=>{"string_value"=>"camry"}}, 
+# "1"=>{"response_group"=>"1", "question_id"=>"25", "179"=>{"string_value"=>"f150"}},
+#  "2"=>{"response_group"=>"2", "question_id"=>"25", "179"=>{"string_value"=>""}}, 
+#  "3"=>{"response_group"=>"3", "question_id"=>"25", "179"=>{"string_value"=>""}}, 
+#  "4"=>{"response_group"=>"4", "question_id"=>"25", "179"=>{"string_value"=>""}}}, 
+# 
+# "26"=>{
+# "0"=>{"response_group"=>"0", "question_id"=>"26", "180"=>{"string_value"=>"1999"}},
+#  "1"=>{"response_group"=>"1", "question_id"=>"26", "180"=>{"string_value"=>"2004"}}, 
+#  "2"=>{"response_group"=>"2", "question_id"=>"26", "180"=>{"string_value"=>""}}, 
+#  "3"=>{"response_group"=>"3", "question_id"=>"26", "180"=>{"string_value"=>""}}, 
+#  "4"=>{"response_group"=>"4", "question_id"=>"26", "180"=>{"string_value"=>""}}}, 
+# 
+# "27"=>{
+# "0"=>{"182"=>{"integer_value"=>""}, "response_group"=>"0", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+# "1"=>{"182"=>{"integer_value"=>""}, "response_group"=>"1", "question_id"=>"27", "181"=>{"string_value"=>""}},
+#  "2"=>{"182"=>{"integer_value"=>""}, "response_group"=>"2", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+#  "3"=>{"182"=>{"integer_value"=>""}, "response_group"=>"3", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+#  "4"=>{"182"=>{"integer_value"=>""}, "response_group"=>"4", "question_id"=>"27", "181"=>{"string_value"=>""}}}},
+
+# 0,1,2,3,4 are the response group numbers
+# and anything else in the response group hash is handled normally