hssc_surveyor 1.4.1.pre

data/lib/surveyor/helpers/surveyor_helper_methods.rb

@@ -0,0 +1,103 @@
+require 'surveyor/helpers/asset_pipeline'
+
+module Surveyor
+  module Helpers
+    module SurveyorHelperMethods
+      include AssetPipeline
+
+      # Layout: stylsheets and javascripts
+      def surveyor_includes
+        if asset_pipeline_enabled?
+          stylesheet_link_tag('surveyor_all') + javascript_include_tag('surveyor_all')
+        else
+          stylesheet_link_tag('surveyor/reset',
+                              'surveyor/jquery-ui-1.10.0.custom',
+                              'surveyor/jquery-ui-timepicker-addon',
+                              'surveyor/ui.slider.extras',
+                              'surveyor/results',
+                              'surveyor',
+                              'custom') +
+          javascript_include_tag('surveyor/jquery-1.9.0',
+                                  'surveyor/jquery-ui-1.10.0.custom',
+                                  'surveyor/jquery-ui-timepicker-addon',
+                                  'surveyor/jquery.selectToUISlider',
+                                  'surveyor/jquery.surveyor',
+                                  'surveyor/jquery.maskedinput')
+        end
+      end
+      # Helper for displaying warning/notice/error flash messages
+      def flash_messages(types)
+        types.map{|type| content_tag(:div, "#{flash[type]}".html_safe, :class => type.to_s)}.join.html_safe
+      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.translation(I18n.locale)[:title], :name => "section[#{section.id}]")
+      end
+      def previous_section
+        # use copy in memory instead of making extra db calls
+        submit_tag(t('surveyor.previous_section').html_safe, :name => "section[#{@sections[@sections.index(@section)-1].id}]") unless @sections.first == @section
+      end
+      def next_section
+        # use copy in memory instead of making extra db calls
+        @sections.last == @section ? submit_tag(t('surveyor.click_here_to_finish').html_safe, :name => "finish") : submit_tag(t('surveyor.next_section').html_safe, :name => "section[#{@sections[@sections.index(@section)+1].id}]")
+      end
+
+      # Questions
+      def q_text(q, context=nil, locale=nil)
+        "#{next_question_number(q) unless (q.dependent? or q.display_type == "label" or q.display_type == "image" or q.part_of_group?)}#{q.text_for(nil, context, locale)}"
+      end
+
+      def next_question_number(question)
+        @n ||= 0
+        "<span class='qnum'>#{@n += 1}) </span>"
+      end
+
+      # Responses
+      def rc_to_attr(type_sym)
+        case type_sym.to_s
+        when /^answer$/ then :answer_id
+        else "#{type_sym.to_s}_value".to_sym
+        end
+      end
+
+      def rc_to_as(type_sym)
+        case type_sym.to_s
+        when /(integer|float|date|time|datetime)/ then :string
+        else type_sym
+        end
+      end
+
+      def generate_pick_none_input_html(value, default_value, css_class, response_class, disabled, input_mask, input_mask_placeholder)
+        html = {}
+        html[:class] = [response_class,css_class].reject{ |c| c.blank? }
+        html[:value] = value.blank? ? default_value : value
+        html[:disabled] = disabled unless disabled.blank?
+        if input_mask
+          html[:'data-input-mask'] = input_mask
+          html[:'data-input-mask-placeholder'] = input_mask_placeholder unless input_mask_placeholder.blank?
+        end
+        html
+      end
+
+      # Responses
+      def response_for(response_set, question, answer = nil, response_group = nil)
+        return nil unless response_set && question && question.id
+        result = response_set.responses.detect{|r| (r.question_id == question.id) && (answer.blank? ? true : r.answer_id == answer.id) && (r.response_group.blank? ? true : r.response_group.to_i == response_group.to_i)}
+        result.blank? ? response_set.responses.build(:question_id => question.id, :response_group => response_group) : result
+      end
+      def response_idx(increment = true)
+        @rc ||= 0
+        (increment ? @rc += 1 : @rc).to_s
+      end
+    end
+  end
+end

data/lib/surveyor/models/answer_methods.rb

@@ -0,0 +1,86 @@
+require 'surveyor/common'
+
+module Surveyor
+  module Models
+    module AnswerMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :question
+        base.send :has_many, :responses
+        base.send :has_many, :validations, :dependent => :destroy
+
+        # Scopes
+        base.send :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
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :question_id, :allow_nil => false, :only_integer => true
+          @@validations_already_included = true
+        end
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :question, :question_id, :text, :short_text, :help_text, :weight, :response_class, :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier, :display_order, :is_exclusive, :display_length, :custom_class, :custom_renderer, :default_value, :display_type, :input_mask, :input_mask_placeholder
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.is_exclusive ||= false
+        self.display_type ||= "default"
+        self.response_class ||= "answer"
+        self.short_text ||= text
+        self.data_export_identifier ||= Surveyor::Common.normalize(text)
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+      def display_type=(val)
+        write_attribute(:display_type, val.nil? ? nil : val.to_s)
+      end
+
+      def css_class
+        [(is_exclusive ? "exclusive" : nil), custom_class].compact.join(" ")
+      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 default_value_for(context = nil, locale = nil)
+        in_context(translation(locale)[:default_value], 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 translation(locale)
+        {:text => self.text, :help_text => self.help_text, :default_value => self.default_value}.with_indifferent_access.merge(
+          (self.question.translation(locale)[:answers] || {})[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/dependency_condition_methods.rb

@@ -0,0 +1,72 @@
+module Surveyor
+  module Models
+    module DependencyConditionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :answer
+        base.send :belongs_to, :dependency
+        base.send :belongs_to, :dependent_question, :foreign_key => :question_id, :class_name => :question
+        base.send :belongs_to, :question
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :operator, :rule_key
+          base.send :validate, :validates_operator
+          base.send :validates_uniqueness_of, :rule_key, :scope => :dependency_id
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :question_id, :dependency_id
+
+          @@validations_already_included = true
+        end
+
+        base.send :include, Surveyor::ActsAsResponse # includes "as" instance method
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :dependency, :question, :answer, :dependency_id, :rule_key, :question_id, :operator, :answer_id, :datetime_value, :integer_value, :float_value, :unit, :text_value, :string_value, :response_other
+
+        # Class methods
+        base.instance_eval do
+          def operators
+            Surveyor::Common::OPERATORS
+          end
+        end
+      end
+
+      # Instance methods
+      def to_hash(response_set)
+        # all responses to associated question
+        responses = question.blank? ? [] : response_set.responses.where("responses.answer_id in (?)", question.answer_ids).all
+        if self.operator.match /^count(>|>=|<|<=|==|!=)\d+$/
+          op, i = self.operator.scan(/^count(>|>=|<|<=|==|!=)(\d+)$/).flatten
+          # logger.warn({rule_key.to_sym => responses.count.send(op, i.to_i)})
+          return {rule_key.to_sym => (op == "!=" ? !responses.count.send("==", i.to_i) : responses.count.send(op, i.to_i))}
+        elsif operator == "!=" and (responses.blank? or responses.none?{|r| r.answer.id == self.answer.id})
+          # logger.warn( {rule_key.to_sym => true})
+          return {rule_key.to_sym => true}
+        elsif response = responses.detect{|r| r.answer.id == self.answer.id}
+          klass = response.answer.response_class
+          klass = "answer" if self.as(klass).nil? # it should compare answer ids when the dependency condition *_value is nil
+          case self.operator
+          when "==", "<", ">", "<=", ">="
+            # logger.warn( {rule_key.to_sym => response.as(klass).send(self.operator, self.as(klass))})
+            return {rule_key.to_sym => !response.as(klass).nil? && response.as(klass).send(self.operator, self.as(klass))}
+          when "!="
+            # logger.warn( {rule_key.to_sym => !response.as(klass).send("==", self.as(klass))})
+            return {rule_key.to_sym => !response.as(klass).send("==", self.as(klass))}
+          end
+        end
+        # logger.warn({rule_key.to_sym => false})
+        {rule_key.to_sym => false}
+      end
+
+    protected
+
+      def validates_operator
+        errors.add(:operator, "Invalid operator") unless
+          Surveyor::Common::OPERATORS.include?(self.operator) ||
+            self.operator && self.operator.match(/^count(<|>|==|>=|<=|!=)(\d+)/)
+      end
+    end
+  end
+end

data/lib/surveyor/models/dependency_methods.rb

@@ -0,0 +1,60 @@
+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)+$/ #TODO properly formed parenthesis etc.
+          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
+        
+        # Whitelisting attributes
+        base.send :attr_accessible, :question, :question_group, :question_id, :question_group_id, :rule
+        
+        # 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,61 @@
+require 'surveyor/common'
+
+module Surveyor
+  module Models
+    module QuestionGroupMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions
+        base.send :has_one, :dependency
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :text, :help_text, :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier, :display_type, :custom_class, :custom_renderer
+      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,115 @@
+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.send :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
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :survey_section, :question_group, :survey_section_id, :question_group_id, :text, :short_text, :help_text, :pick, :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier, :display_order, :display_type, :is_mandatory, :display_width, :custom_class, :custom_renderer, :correct_answer_id
+      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,132 @@
+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
+
+        base.send :has_attached_file, :file
+
+        @@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
+
+        # Whitelisting attributes
+        base.send :attr_accessible, :response_set, :question, :answer, :date_value, :time_value, :response_set_id, :question_id, :answer_id, :datetime_value, :integer_value, :float_value, 
+                  :unit, :text_value, :string_value, :response_other, :response_group, :survey_section_id, :file
+
+        # 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