affectiva-surveyor 1.5.0.pre.disco.2

data/lib/surveyor/models/dependency_methods.rb

@@ -0,0 +1,57 @@
+module Surveyor
+  module Models
+    module DependencyMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :question
+        base.send :belongs_to, :question_group
+        base.send :has_many, :dependency_conditions, :dependent => :destroy
+        
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :rule
+          base.send :validates_format_of, :rule, :with => /^(?:and|or|\)|\(|[A-Z]|\s)+$/, :multiline => true #TODO properly formed parenthesis etc. # SMELL with :multiline => true Rails reports a security risk
+          base.send :validates_numericality_of, :question_id, :if => Proc.new { |d| d.question_group_id.nil? }
+          base.send :validates_numericality_of, :question_group_id, :if => Proc.new { |d| d.question_id.nil? }
+          
+          @@validations_already_included = true
+        end
+
+        # Attribute aliases
+        base.send :alias_attribute, :dependent_question_id, :question_id
+      end
+
+      # Instance Methods
+      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) ? "\\b#{dc.rule_key}(?!nd|r)\\b" : "\\b#{dc.rule_key}\\b"}.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
+  end
+end

data/lib/surveyor/models/question_group_methods.rb

@@ -0,0 +1,58 @@
+require 'surveyor/common'
+
+module Surveyor
+  module Models
+    module QuestionGroupMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions
+        base.send :has_one, :dependency
+      end
+
+      include MustacheContext
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.display_type ||= "inline"
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+
+      def renderer
+        display_type.blank? ? :default : display_type.to_sym
+      end
+
+      def display_type=(val)
+        write_attribute(:display_type, val.nil? ? nil : val.to_s)
+      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? ? "g_dependent" : nil), (triggered?(response_set) ? nil : "g_hidden"), custom_class].compact.join(" ")
+      end
+
+      def text_for(context = nil, locale = nil)
+        return "" if display_type == "hidden_label"
+        in_context(translation(locale)[:text], context)
+      end
+      def help_text_for(context = nil, locale = nil)
+        in_context(translation(locale)[:help_text], context)
+      end
+
+      def translation(locale)
+        {:text => self.text, :help_text => self.help_text}.with_indifferent_access.merge(
+          (self.questions.first.survey_section.survey.translation(locale)[:question_groups] || {})[self.reference_identifier] || {}
+        )
+      end
+    end
+  end
+end

data/lib/surveyor/models/question_methods.rb

@@ -0,0 +1,112 @@
+require 'surveyor/common'
+
+module Surveyor
+  module Models
+    module QuestionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey_section
+        base.send :belongs_to, :question_group, :dependent => :destroy
+        base.send :has_many, :answers, :dependent => :destroy # it might not always have answers
+        base.send :has_one, :dependency, :dependent => :destroy
+        base.send :belongs_to, :correct_answer, :class_name => "Answer", :dependent => :destroy
+
+        # Scopes
+        base.instance_eval {default_scope ->{order "#{base.quoted_table_name}.display_order ASC"}}
+
+        # Mustache
+        base.send :include, MustacheContext
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :text, :display_order
+          # this causes issues with building and saving
+          #, :survey_section_id
+          base.send :validates_inclusion_of, :is_mandatory, :in => [true, false]
+
+          @@validations_already_included = true
+
+        end
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.is_mandatory ||= false
+        self.display_type ||= "default"
+        self.pick ||= "none"
+        self.data_export_identifier ||= Surveyor::Common.normalize(text)
+        self.short_text ||= text
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+
+      def pick=(val)
+        write_attribute(:pick, val.nil? ? nil : val.to_s)
+      end
+      def display_type=(val)
+        write_attribute(:display_type, val.nil? ? nil : val.to_s)
+      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? ? "q_dependent" : nil), (triggered?(response_set) ? nil : "q_hidden"), custom_class].compact.join(" ")
+      end
+
+      def part_of_group?
+        !self.question_group.nil?
+      end
+      def solo?
+        self.question_group.nil?
+      end
+
+      def text_for(position = nil, context = nil, locale = nil)
+        return "" if display_type == "hidden_label"
+        imaged(split(in_context(translation(locale)[:text], context), position))
+      end
+      def help_text_for(context = nil, locale = nil)
+        in_context(translation(locale)[:help_text], context)
+      end
+      def split(text, position=nil)
+        case position
+        when :pre
+          text.split("|",2)[0]
+        when :post
+          text.split("|",2)[1]
+        else
+          text
+        end.to_s
+      end
+      def renderer(g = question_group)
+        r = [g ? g.renderer.to_s : nil, display_type].compact.join("_")
+        r.blank? ? :default : r.to_sym
+      end
+      def translation(locale)
+        {:text => self.text, :help_text => self.help_text}.with_indifferent_access.merge(
+          (self.survey_section.survey.translation(locale)[:questions] || {})[self.reference_identifier] || {}
+        )
+      end
+
+      private
+
+
+      def imaged(text)
+        self.display_type == "image" && !text.blank? ? ActionController::Base.helpers.image_tag(text) : text
+      end
+
+    end
+  end
+end

data/lib/surveyor/models/response_methods.rb

@@ -0,0 +1,126 @@
+module Surveyor
+  module Models
+    module ResponseMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :response_set
+        base.send :belongs_to, :question
+        base.send :belongs_to, :answer
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :question_id, :answer_id
+
+          @@validations_already_included = true
+        end
+        base.send :include, Surveyor::ActsAsResponse # includes "as" instance method
+
+        # Class methods
+        base.instance_eval do
+          def applicable_attributes(attrs)
+            result = HashWithIndifferentAccess.new(attrs)
+            answer_id = result[:answer_id].is_a?(Array) ? result[:answer_id].last : result[:answer_id] # checkboxes are arrays / radio buttons are not arrays
+            if result[:string_value] && !answer_id.blank? && Answer.exists?(answer_id)
+              answer = Answer.find(answer_id)
+              result.delete(:string_value) unless answer.response_class && answer.response_class.to_sym == :string
+            end
+            result
+          end
+        end
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+
+      def answer_id=(val)
+        write_attribute :answer_id, (val.is_a?(Array) ? val.detect{|x| !x.to_s.blank?} : val)
+      end
+      def correct?
+        question.correct_answer.nil? or self.answer.response_class != "answer" or (question.correct_answer.id.to_i == answer.id.to_i)
+      end
+
+      def time_value
+        read_attribute(:datetime_value).strftime( time_format ) unless read_attribute(:datetime_value).blank?
+      end
+
+      def time_value=(val)
+        self.datetime_value =
+          if val && time = Time.zone.parse("#{Date.today.to_s} #{val}")
+            time.to_datetime
+          else
+            nil
+          end
+      end
+
+      def date_value
+        read_attribute(:datetime_value).strftime( date_format ) unless read_attribute(:datetime_value).blank?
+      end
+
+      def date_value=(val)
+        self.datetime_value =
+          if val && time = Time.zone.parse(val)
+            time.to_datetime
+          else
+            nil
+          end
+      end
+
+      def time_format
+        '%H:%M'
+      end
+
+      def date_format
+        '%Y-%m-%d'
+      end
+
+      def datetime_format
+        '%Y-%m-%d %H:%M:%S'
+      end
+
+      def to_formatted_s
+        return "" if answer.nil? || answer.response_class.nil?
+        return case t = answer.response_class.to_sym
+               when :string, :text, :integer, :float
+                 send("#{t}_value".to_sym).to_s
+               when :date
+                 date_value
+               when :time
+                 time_value
+               when :datetime
+                 (read_attribute(:datetime_value).strftime( datetime_format ) unless read_attribute(:datetime_value).blank?) || ''
+               else
+                 to_s
+               end
+      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
+
+      def json_value
+        return nil if answer.response_class == "answer"
+
+        formats = {
+          'datetime' => '%Y-%m-%dT%H:%M%:z',
+          'date' => '%Y-%m-%d',
+          'time' => '%H:%M'
+        }
+
+        found = formats[answer.response_class]
+        found ? datetime_value.try{|d| d.utc.strftime(found)} : as(answer.response_class)
+      end
+    end
+  end
+end

data/lib/surveyor/models/response_set_methods.rb

@@ -0,0 +1,188 @@
+require 'rabl'
+
+module Surveyor
+  module Models
+    module ResponseSetMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey
+        base.send :belongs_to, :user
+        base.instance_eval {has_many :responses, ->{order "#{Response.quoted_table_name}.created_at ASC"}, :dependent => :destroy}
+        base.send :accepts_nested_attributes_for, :responses, :allow_destroy => true
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :survey_id
+          base.send :validates_associated, :responses
+          base.send :validates_uniqueness_of, :access_code
+
+          @@validations_already_included = true
+        end
+
+        base.send :before_create, :ensure_start_timestamp
+        base.send :before_create, :ensure_identifiers
+
+        # Class methods
+        base.instance_eval do
+          def has_blank_value?(hash)
+            return true if hash["answer_id"].blank?
+            return false if (q = Question.find_by_id(hash["question_id"])) and q.pick == "one"
+            hash.any?{|k,v| v.is_a?(Array) ? v.all?{|x| x.to_s.blank?} : v.to_s.blank?}
+          end
+        end
+      end
+
+      def ensure_start_timestamp
+        self.started_at ||= Time.now
+      end
+
+      def ensure_identifiers
+        self.access_code ||= Surveyor::Common.make_tiny_code
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+
+      def to_csv(access_code = false, print_header = true)
+        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)
+        result = Surveyor::Common.csv_impl.generate do |csv|
+          if print_header
+            csv << (access_code ? ["response set access code"] : []) +
+              qcols.map{|qcol| "question.#{qcol}"} +
+              acols.map{|acol| "answer.#{acol}"} +
+              rcols.map{|rcol| "response.#{rcol}"}
+          end
+          responses.each do |response|
+            csv << (access_code ? [self.access_code] : []) +
+              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 as_json(options = nil)
+        template_paths = ActionController::Base.view_paths.collect(&:to_path)
+        Rabl.render(self, 'surveyor/show.json', :view_path => template_paths, :format => "hash")
+      end
+
+      def complete!
+        self.completed_at = Time.now
+      end
+
+      def complete?
+        !completed_at.nil?
+      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
+      def is_group_unanswered?(group)
+        group.questions.any?{|question| is_unanswered?(question)}
+      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
+        unanswered_question_dependencies + unanswered_question_group_dependencies
+      end
+
+      def unanswered_question_dependencies
+        dependencies.select{ |d| d.question && self.is_unanswered?(d.question) && d.is_met?(self) }.map(&:question)
+      end
+
+      def unanswered_question_group_dependencies
+        dependencies.
+          select{ |d| d.question_group && self.is_group_unanswered?(d.question_group) && d.is_met?(self) }.
+          map(&:question_group)
+      end
+
+      def all_dependencies(question_ids = nil)
+        arr = dependencies(question_ids).partition{|d| d.is_met?(self) }
+        {
+          :show => arr[0].map{|d| d.question_group_id.nil? ? "q_#{d.question_id}" : "g_#{d.question_group_id}"},
+          :hide => arr[1].map{|d| d.question_group_id.nil? ? "q_#{d.question_id}" : "g_#{d.question_group_id}"}
+        }
+      end
+
+      # Check existence of responses to questions from a given survey_section
+      def no_responses_for_section?(section)
+        !responses.any?{|r| r.survey_section_id == section.id}
+      end
+
+      def update_from_ui_hash(ui_hash)
+        transaction do
+          ui_hash.each do |ord, response_hash|
+            api_id = response_hash['api_id']
+            fail "api_id missing from response #{ord}" unless api_id
+
+            existing = Response.where(:api_id => api_id).first
+            updateable_attributes = response_hash.reject { |k, v| k == 'api_id' }
+
+            if self.class.has_blank_value?(response_hash)
+              existing.destroy if existing
+            elsif existing
+              if existing.question_id.to_s != updateable_attributes['question_id']
+                fail "Illegal attempt to change question for response #{api_id}."
+              end
+
+              existing.update_attributes(updateable_attributes)
+            else
+              responses.build(updateable_attributes).tap do |r|
+                r.api_id = api_id
+                r.save!
+              end
+            end
+
+          end
+        end
+      end
+
+      protected
+
+      def dependencies(question_ids = nil)
+        question_ids = survey.sections.map(&:questions).flatten.map(&:id) if responses.blank? and question_ids.blank?
+        deps = Dependency.includes(:dependency_conditions).
+          where({:dependency_conditions => {:question_id => question_ids || responses.map(&:question_id)}})
+        # this is a work around for a bug in active_record in rails 2.3 which incorrectly eager-loads associatins when a
+        # condition clause includes an association limiter
+        deps.each{|d| d.dependency_conditions.reload}
+        deps
+      end
+    end
+  end
+end