hssc_surveyor 1.4.1.pre

data/lib/surveyor/models/response_set_methods.rb

@@ -0,0 +1,196 @@
+require 'rabl'
+require 'paperclip'
+
+module Surveyor
+  module Models
+    module ResponseSetMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey
+        base.send :belongs_to, :user
+        base.send :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
+
+        # Attributes
+        base.send :attr_protected, :completed_at
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :survey, :responses_attributes, :user_id, :survey_id
+
+        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.all(:include => :dependency_conditions,
+          :conditions => {: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

data/lib/surveyor/models/survey_methods.rb

@@ -0,0 +1,103 @@
+require 'surveyor/common'
+require 'rabl'
+
+module Surveyor
+  module Models
+    module SurveyMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :sections, :class_name => "SurveySection", :order => "#{SurveySection.quoted_table_name}.display_order", :dependent => :destroy
+        base.send :has_many, :sections_with_questions, :include => :questions, :class_name => "SurveySection", :order => "#{SurveySection.quoted_table_name}.display_order"
+        base.send :has_many, :response_sets
+        base.send :has_many, :translations, :class_name => "SurveyTranslation"
+
+        # Scopes
+        base.send :scope, :with_sections, {:include => :sections}
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :title
+          base.send :validates_uniqueness_of, :survey_version, :scope => :access_code, :message => "survey with matching access code and version already exists"
+
+          @@validations_already_included = true
+        end
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :title, :description, :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier, :css_url, :custom_class, :display_order
+
+        # Derived attributes
+        base.send :before_save, :generate_access_code
+        base.send :before_save, :increment_version
+
+        # Class methods
+        base.instance_eval do
+          def to_normalized_string(value)
+            # replace non-alphanumeric with "-". remove repeat "-"s. don't start or end with "-"
+            value.to_s.downcase.gsub(/[^a-z0-9]/,"-").gsub(/-+/,"-").gsub(/-$|^-/,"")
+          end
+        end
+      end
+
+      # Instance methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.api_id ||= Surveyor::Common.generate_api_id
+        self.display_order ||= Survey.count
+      end
+
+      def active?
+        self.active_as_of?(DateTime.now)
+      end
+      def active_as_of?(date)
+        (active_at && active_at < date && (!inactive_at || inactive_at > date)) ? true : false
+      end
+      def activate!
+        self.active_at = DateTime.now
+        self.inactive_at = nil
+      end
+      def deactivate!
+        self.inactive_at = DateTime.now
+        self.active_at = nil
+      end
+
+      def as_json(options = nil)
+        template_paths = ActionController::Base.view_paths.collect(&:to_path)
+        Rabl.render(filtered_for_json, 'surveyor/export.json', :view_path => template_paths, :format => "hash")
+      end
+
+      ##
+      # A hook that allows the survey object to be modified before it is
+      # serialized by the #as_json method.
+      def filtered_for_json
+        self
+      end
+
+      def default_access_code
+        self.class.to_normalized_string(title)
+      end
+
+      def generate_access_code
+        self.access_code ||= default_access_code
+      end
+
+      def increment_version
+        surveys = self.class.select(:survey_version).where(:access_code => access_code).order("survey_version DESC")
+        next_version = surveys.any? ? surveys.first.survey_version.to_i + 1 : 0
+
+        self.survey_version = next_version
+      end
+
+      def translation(locale_symbol)
+        t = self.translations.where(:locale => locale_symbol.to_s).first
+        {:title => self.title, :description => self.description}.with_indifferent_access.merge(
+          t ? YAML.load(t.translation || "{}").with_indifferent_access : {}
+        )
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_section_methods.rb

@@ -0,0 +1,56 @@
+module Surveyor
+  module Models
+    module SurveySectionMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions, :dependent => :destroy
+        base.send :belongs_to, :survey
+
+        # Scopes
+        base.send :scope, :with_includes, { :include => {:questions => [:answers, :question_group, {:dependency => :dependency_conditions}]}}
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :title, :display_order
+          # this causes issues with building and saving
+          #, :survey
+
+          @@validations_already_included = true
+        end
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :survey, :survey_id, :title, :description, :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier, :display_order, :custom_class
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.data_export_identifier ||= Surveyor::Common.normalize(title)
+      end
+
+      def questions_and_groups
+        qs = []
+        questions.each_with_index.map do |q,i|
+          if q.part_of_group?
+            if (i+1 >= questions.size) or (q.question_group_id != questions[i+1].question_group_id)
+              q.question_group
+            end
+          else
+            q
+          end
+        end.compact
+      end
+
+      def translation(locale)
+        {:title => self.title, :description => self.description}.with_indifferent_access.merge(
+          (self.survey.translation(locale)[:survey_sections] || {})[self.reference_identifier] || {}
+        )
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_translation_methods.rb

@@ -0,0 +1,33 @@
+module Surveyor
+  module Models
+    module SurveyTranslationMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :locale, :translation
+          base.send :validates_uniqueness_of, :locale, :scope => :survey_id
+          # this causes issues with building and saving
+          #, :survey
+
+          @@validations_already_included = true
+        end
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :survey, :survey_id, :locale, :translation
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+      end
+    end
+  end
+end

data/lib/surveyor/models/validation_condition_methods.rb

@@ -0,0 +1,56 @@
+module Surveyor
+  module Models
+    module ValidationConditionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :validation
+
+        # Scopes
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :operator, :rule_key
+          base.send :validates_inclusion_of, :operator, :in => Surveyor::Common::OPERATORS
+          base.send :validates_uniqueness_of, :rule_key, :scope => :validation_id
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :validation_id #, :question_id, :answer_id
+          
+          @@validations_already_included = true
+        end
+        
+        base.send :include, Surveyor::ActsAsResponse # includes "as" instance method
+        
+        # Whitelisting attributes
+        base.send :attr_accessible, :validation, :validation_id, :rule_key, :operator, :question_id, :answer_id, :datetime_value, :integer_value, :float_value, :unit, :text_value, :string_value, :response_other, :regexp
+        
+        # Class methods
+        base.instance_eval do
+          def operators
+            Surveyor::Common::OPERATORS
+          end
+        end
+      end
+
+      # Instance Methods
+      def to_hash(response)
+        {rule_key.to_sym => (response.nil? ? false : self.is_valid?(response))}
+      end
+
+      def is_valid?(response)
+        klass = response.answer.response_class
+        compare_to = Response.find_by_question_id_and_answer_id(self.question_id, self.answer_id) || self
+        case self.operator
+        when "==", "<", ">", "<=", ">="
+          response.as(klass).send(self.operator, compare_to.as(klass))
+        when "!="
+          !(response.as(klass) == compare_to.as(klass))
+        when "=~"
+          return false if compare_to != self
+          !(response.as(klass).to_s =~ Regexp.new(self.regexp || "")).nil?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/surveyor/models/validation_methods.rb

@@ -0,0 +1,48 @@
+module Surveyor
+  module Models
+    module ValidationMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :answer
+        base.send :has_many, :validation_conditions, :dependent => :destroy
+
+        # Scopes
+        
+        @@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)+$/
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :answer_id
+          
+          @@validations_already_included = true
+        end
+        
+        # Whitelisting attributes
+        base.send :attr_accessible, :answer, :answer_id, :rule, :message
+      end
+
+      # Instance Methods
+      def is_valid?(response_set)
+        ch = conditions_hash(response_set)
+        rgx = Regexp.new(self.validation_conditions.map{|vc| ["a","o"].include?(vc.rule_key) ? "#{vc.rule_key}(?!nd|r)" : vc.rule_key}.join("|")) # exclude and, or
+        # logger.debug "v: #{self.inspect}"
+        # 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]}}"
+        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 = {}
+        response = response_set.responses.detect{|r| r.answer_id.to_i == self.answer_id.to_i}
+        # logger.debug "r: #{response.inspect}"
+        self.validation_conditions.each{|vc| hash.merge!(vc.to_hash(response))}
+        return hash
+      end
+    end
+  end
+end

data/lib/surveyor/mustache_context.rb

@@ -0,0 +1,11 @@
+module Surveyor
+  module MustacheContext
+    def in_context(text, context=nil)
+      case context
+      when NilClass then text
+      when Hash     then Mustache.render(text, context)
+      else               context.render(text)
+      end
+    end
+  end
+end