surveyor_gui 0.0.3

data/app/controllers/surveyor_gui/responses_controller.rb

@@ -0,0 +1,39 @@
+class SurveyorGui::ResponsesController < ApplicationController
+  include ReportPreviewWrapper
+  # ReportPreviewWrapper wraps preview in a database transaction so test data is not permanently saved.
+  around_action :wrap_in_transaction, only: :preview
+  layout 'surveyor_gui_default'
+
+  def index
+    @title = "Survey Responses"
+    @response_sets = Survey.find_by_id(params[:id]).response_sets
+  end
+ 
+  def preview 
+    user_id = defined?(current_user) && current_user ? current_user.id : nil 
+    @title = "Show Response"
+    @survey = Survey.find(params[:survey_id])
+    @response_set = ResponseSet.create(:survey => @survey, :user_id => user_id, :test_data => true)
+    ReportResponseGenerator.new(@survey).generate_1_result_set(@response_set)
+    @responses = @response_set.responses
+    if (!@survey)
+      flash[:notice] = "Survey/Questionnnaire not found."
+      redirect_to :back
+    end
+    render :show    
+  end
+
+  def show
+    @title = "Show Response"
+    @response_set = ResponseSet.find(params[:id])
+    @survey = @response_set.survey
+    @responses = @response_set.responses
+    if (!@response_set)
+      flash[:error] = "Response not found"
+      redirect_to :back
+    elsif (!@survey)
+      flash[:error] = "Survey/Questionnnaire not found."
+      redirect_to :back
+    end
+  end
+end

data/app/controllers/surveyor_gui/survey_controller.rb

@@ -0,0 +1,16 @@
+class SurveyorGui::SurveyController < ApplicationController
+  def show
+    @title = "User Will See this Survey"
+    @survey = Survey.find(params[:survey_id])
+    user_id = defined?(current_user) ? current_user.id : 1 
+    ResponseSet.where('survey_id = ? and test_data = ? and user_id = ?',params[:survey_id],true, user_id).each {|r| r.destroy}
+    @response_set = ResponseSet.create(:survey => @survey, :user_id => user_id, :test_data => true)
+    if (@survey)
+      flash[:notice] = t('surveyor.survey_started_success')
+      redirect_to surveyor.edit_my_survey_path @survey.access_code, @response_set.access_code
+    else
+      flash[:notice] = "Survey not found."
+      redirect :back
+    end
+  end
+end

data/app/facades/report_formatter.rb

@@ -0,0 +1,44 @@
+class ReportFormatter
+
+  STAT_FUNCTIONS = {
+    sum: ->(arr){arr.sum},
+    min: ->(arr){arr.min},
+    max: ->(arr){arr.max},
+    average: ->(arr){arr.average}
+  }
+
+  STAT_FORMATS = {
+    number: "%g",
+    date: "%m-%d-%y",
+    time: "%I:%M:%S %P",
+    datetime: "%m-%d-%y %I:%M:%S %P"
+  }
+
+  def initialize(question, responses)
+    @question = question
+    @responses = responses
+  end
+
+  def stats(stat_function)
+    stat = calculate_stats(stat_function)
+    format_stats(stat)
+  end
+
+  def calculate_stats(stat_function)
+    arr =  @responses.where(:question_id => @question.id).map{|r| r.response_value.to_f}
+    STAT_FUNCTIONS[stat_function].call(arr)
+  end
+  
+  def format_stats(stat)
+    if @question.question_type_id == :number
+      STAT_FORMATS[@question.question_type_id] % stat 
+    else
+      format_time_stat(stat)
+    end
+  end  
+
+  def format_time_stat(stat)
+      stat = Time.zone.at(stat)     
+      stat.strftime(STAT_FORMATS[@question.question_type_id])
+  end
+end

data/app/facades/report_preview_wrapper.rb

@@ -0,0 +1,11 @@
+module ReportPreviewWrapper
+  def wrap_in_transaction 
+    ActiveRecord::Base.transaction do
+      begin
+        yield
+      ensure
+        raise ActiveRecord::Rollback
+      end
+    end
+  end  
+end

data/app/facades/report_response_generator.rb

@@ -0,0 +1,147 @@
+class ReportResponseGenerator
+  RESPONSE_GENERATOR = {
+    pick_one: pick_one = ->(response, response_set, q, context){ context.send(:make_pick_one, response_set, q) },
+    pick_any: pick_any = ->(response, response_set, q, context){ context.send(:random_anys, response, response_set, q) },
+    dropdown: pick_one,
+    slider:   pick_one,
+    number:   ->(response, response_set, q, context){ response.integer_value = rand(100); response.save },
+    string:   ->(response, response_set, q, context){ response.string_value = context.send(:random_string); response.save },
+    box:      ->(response, response_set, q, context){ response.text_value = context.send(:random_string); response.save },
+    date:     ->(response, response_set, q, context){ response.datetime_value = context.send(:random_date); response.save },
+    datetime: ->(response, response_set, q, context){ response.datetime_value = context.send(:random_date); response.save },
+    time:     ->(response, response_set, q, context){ response.datetime_value = context.send(:random_date); response.save },
+    file:     ->(response, response_set, q, context){ context.send(:make_blob, response, false) },
+    stars:    ->(response, response_set, q, context){ response_set.responses.create(:question_id => q.id, :integer_value => rand(5)+1, :answer_id => q.answers.first.id)},
+    grid_one: pick_one,
+    grid_any: pick_any,
+    grid_dropdown: ->(response, response_set, q, context){ context.send(:grid_dropdown, response, response_set, q) }
+  }
+
+  def initialize(survey)
+    @survey = survey
+  end
+  
+  def generate_1_result_set(response_set)
+    @survey.survey_sections.each do |ss|
+      ss.questions.each do |q|
+        response = response_set.responses.build(:question_id => q.id, :answer_id => q.answers.first ? q.answers.first.id : nil)
+        if q.repeater?
+          rand(5).times.each do 
+            response = response_set.responses.build(:question_id => q.id, :answer_id => q.answers.first.id)
+            RESPONSE_GENERATOR[q.question_type_id].call(response, response_set, q, self)
+          end
+        elsif q.question_type_id != :label
+          RESPONSE_GENERATOR[q.question_type_id].call(response, response_set, q, self)
+        end
+      end
+    end
+  end
+  
+  def random_string
+    whichone = rand(5)
+    case whichone
+    when 0
+      'An answer.'
+    when 1
+      'A different answer.'
+    when 2
+      'Any answer here.'
+    when 3
+      'Some response.'
+    when 4
+      'A random response.'
+    when 5
+      'A random answer.'
+    end
+  end
+  
+  def random_date
+    Time.now + (rand(100)-50).days
+  end
+  
+  def random_pick(question, avoid=[])
+    answer = nil
+    answers = question.answers.is_not_comment
+    while !answer && avoid.count < answers.count
+      pick = rand(answers.count)
+      if !avoid.include?(answers[pick].id)
+        answer=answers[pick].id
+      end
+    end
+    return answer
+  end
+
+  def make_pick_comment(response_set, q)
+    comment = q.answers.is_comment
+    if comment && !comment.empty?
+      response_set.responses.create(question_id: q.id, answer_id: comment.first.id, string_value: "User added a comment here.")
+    end
+  end
+
+  def make_pick_one(response_set, q)
+    if q.is_comment?
+      response_set.responses.create(question_id: q.id, answer_id: q.answers.first.id, string_value: "User added a comment here.")
+    else
+      response_set.responses.create(question_id: q.id, answer_id: random_pick(q)) 
+      make_pick_comment(response_set, q)
+    end
+  end
+  
+  def random_pick_count(question)
+    answers = question.answers
+    return rand(answers.count)+1
+  end
+
+  def make_blob(response, show_blob)
+    response.save!
+    response.blob.store!(File.new(Rails.public_path+'/images/regulations.jpg')) if show_blob
+  end
+
+  def random_any(response, response_set, q)
+    if !q.answers.empty?
+      how_many = random_pick_count(q)
+      how_many.times {
+        already_checked = response_set.responses.where('question_id=?',q.id).collect(&:answer_id)
+        response = response_set.responses.build(:question_id => q.id, :answer_id => random_pick(q,already_checked))
+        response.save
+      }
+    else
+      response = nil
+    end
+  end
+
+  def random_anys(response, response_set, q)
+    if q.is_comment?
+      response_set.responses.create(question_id: q.id, answer_id: q.answers.first.id, string_value: "User added a comment here.")
+    else    
+      random_any(response, response_set, q)
+      make_pick_comment(response_set, q)
+    end
+  end
+
+  def grid_one(response, response_set, q)
+    q.question_group.questions.each do |question|
+      response = response_set.responses.build(question_id: question.id, answer_id: random_pick(question)) 
+      response.save
+    end
+  end
+
+  def random_pick_with_column(question, column)
+    answers = Answer.where(question_id: question.id, column_id: column.id)
+    pick = rand(answers.count)
+    answer=answers[pick].id
+  end
+
+  def grid_dropdown(response, response_set, q)
+    q.question_group.questions.is_not_comment.each do |question|
+      q.question_group.columns.each do |column|
+        response = response_set.responses.build(question_id: q.id, answer_id: random_pick_with_column(question, column), column_id: column.id )
+        response.save
+      end
+    end
+    if question = q.question_group.questions.is_comment.first && question && !question.empty?
+      response_set.responses.create(question_id: question.id, answer_id: question.answers.first.id, column_id: column.id, string_value: "User added comment here")
+    end
+  end
+  
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/app/helpers/dependency_helper.rb

@@ -0,0 +1,5 @@
+module DependencyHelper
+  def link_to_remove_tbody (name, f)
+    f.hidden_field(:_destroy) + link_to(image_tag("delete.png",:border => 0, :margin=>'-1em'), "#", onclick: "remove_dependency_condition(this);")
+  end
+end

data/app/helpers/question_helper.rb

@@ -0,0 +1,22 @@
+module QuestionHelper
+  def link_to_remove_fields (name, f, dom_to_hide=nil)
+    f.hidden_field(:_destroy) + link_to(image_tag("delete.png",:border => 0, :margin=>'-1em'), "#", onclick: "remove_fields(this, \"#{dom_to_hide}\");")
+  end
+
+  def adjusted_text
+    if @question.part_of_group?
+      @question.question_group.text
+    else
+      @question.text
+    end
+  end
+
+  def question_type_subset(args)
+    question_types = QuestionType.all.map{|t|[t.text, t.id]}[0..19].uniq
+    ordered_types = []
+    args.each do |id|
+     ordered_types << question_types.select{|t| id == t[1]}.flatten
+    end
+    ordered_types
+  end
+end

data/app/helpers/surveyform_helper.rb

@@ -0,0 +1,179 @@
+module SurveyformHelper
+  require 'deep_cloneable'
+
+  def list_dependencies(o)
+    controlling_questions = o.controlling_questions
+
+    controlling_question_ids = controlling_questions.map{|q| q.question_number.to_s+')'}.uniq
+    count = controlling_question_ids.count
+    retstr ='This question is shown depending on the '
+    retstr += 'answer'.pluralize(count)
+    retstr += ' to '
+    retstr += 'question'.pluralize(count) + ' '
+    retstr + list_phrase(controlling_question_ids)
+  end
+
+  def list_phrase(args)
+    ## given a list of word parameters, return a syntactically correct phrase
+    ## [dog] = "dog"
+    ## [dog, cat] = "dog and cat"
+    ## [dog, cat, bird] = "dog, cat and bird"
+    case args.count
+    when 0
+      ''
+    when 1
+      args[0]
+    when 2
+      args[0] + ' and ' + args[1]
+    else
+      last = args.count
+      args.take(last - 2).join(', ') + ', ' + args[last - 2] + ' and ' + args[last - 1]
+    end
+  end  
+  
+  def render_questions_and_groups_helper(q, ss)
+    #this method will render either a question or a complete question group.
+    #we always iterate through questions, and if we happen to notice a question
+    #belongs to a group, we process the group at that time.
+    #note that questions carry a question_group_id, and this is how we know
+    #that a question is part of a group, and that it should not be rendered individually,
+    #but as part of a group.  
+    if q.object.part_of_group?
+      _render_initial_group(q, ss)  ||  _respond_to_a_change_in_group_id(q, ss)
+    else
+      render "question_wrapper", f: q
+    end  
+  end
+  
+  def render_one_group(qg)
+    qg.simple_fields_for :questions, @current_group.questions do |f|
+      if f.object.is_comment != true
+        render "question_group_fields", f: f
+      elsif f.object.is_comment == true
+        "</div>".html_safe+(render "question_field", f: f)+"<div>".html_safe
+      end 
+    end
+  end  
+  
+  def question_group_heading(f)
+    if f.object.question_type_id == :grid_dropdown
+      heading = f.object.question_group.columns
+    elsif f.object.question_group.display_type == "grid"
+      heading = f.object.answers
+    else
+      heading = []
+    end  
+    heading.map {|a| "<span class=\"question_group_heading #{f.object.question_type_id.to_s}\" >#{a.text}<\/span>"}.join().html_safe
+  end  
+  
+  def row_label_if_question_group(question)
+    if question.part_of_group? 
+      "<span class=\"row_name\">#{question.text}: </span>".html_safe
+    end
+  end
+  
+  def question_group_class(question)
+    if @current_group.question_group.display_type == "inline"
+      "inline"
+    elsif @current_group.question_group.display_type == "default"
+      "default"
+    else
+      if question.question_type_id == :grid_dropdown
+        "dropdown"
+      else
+        "grid"
+      end
+    end
+  end
+  
+  private
+  def _render_initial_group(q, ss)
+    if @current_group.nil?
+      @current_group = QuestionGroupTracker.new(q.object.question_group_id)
+      render "question_group", :ss => ss, :f => q 
+    end
+  end
+  
+  def _respond_to_a_change_in_group_id(q, ss)
+    if @current_group.question_group_id != q.object.question_group_id
+      @current_group = QuestionGroupTracker.new(q.object.question_group_id)
+      render "question_group", :ss => ss, :f => q 
+    end
+  end
+
+end
+
+class SurveyCloneFactory
+  def initialize(id, as_template=false)
+    @survey = Surveyform.find(id.to_i)
+    @as_template = as_template
+  end
+
+  def clone
+    cloned_survey = _deep_clone 
+    _set_api_keys(cloned_survey)
+    if cloned_survey.save!
+      return cloned_survey 
+    else
+      raise cloned_survey.errors.messages.map{|m| m}.join(',')
+      return nil
+    end
+  end
+  
+  private
+  
+  def _initial_clone
+    initial_clone = @survey
+    initial_clone.api_id = Surveyor::Common.generate_api_id                                                       
+    initial_clone.survey_version = Survey.where(access_code: @survey.access_code).maximum(:survey_version) + 1  
+    return initial_clone
+  end 
+
+  def _deep_clone
+    _initial_clone.deep_clone include: { 
+      sections:   
+        {
+          questions: [
+            :answers,
+            {dependency: :dependency_conditions},
+            {question_group: :columns}
+          ]
+        }
+    }, 
+    use_dictionary: true
+  end 
+
+  def _set_api_keys(cloned_survey)
+    cloned_survey.sections.each do |section|
+      section.questions.each do |question|
+        question.api_id = Surveyor::Common.generate_api_id
+        question.question_group.api_id = Surveyor::Common.generate_api_id if question.part_of_group?
+        question.answers.each do |answer|
+          answer.api_id = Surveyor::Common.generate_api_id
+        end
+      end
+    end
+  end
+end
+
+class QuestionGroupTracker
+  attr_reader :questions, :question_group_id, :question_group
+  def initialize(question_group_id)
+    @questions = Question.where('question_group_id=?',question_group_id)
+    @counter = 0
+    @question_group_id = question_group_id
+    @question_group = QuestionGroup.find(question_group_id)
+  end
+
+  def check_for_new_group(question)
+    if question.question_group_id != @question_group_id || !defined?(@initial_check)
+      initialize(question.question_group_id)
+      @initial_check = true
+      return true
+    else
+      return false
+    end
+  end
+end
+
+