upgrade_surveyor_gui 0.1.2

data/app/controllers/surveyor_gui/responses_controller.rb

@@ -0,0 +1,41 @@
+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/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
+    @response_sets = [@response_set]
+    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
+    @response_sets = [@response_set]
+    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 ? 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/controllers/surveyor_gui/survey_sections_controller.rb

@@ -0,0 +1,80 @@
+class SurveyorGui::SurveySectionsController < ApplicationController
+  layout 'surveyor_gui/surveyor_gui_blank'
+
+  def new
+    @title = "Add Survey Section"
+    survey = Survey.find(params[:survey_id])
+    prev_section = SurveySection.find(params[:prev_section_id])
+    @last_survey_section = survey.survey_sections.last
+    @survey_section = survey.survey_sections
+                            .build(:title => 'New Section',
+                                   :display_order => prev_section.display_order + 1,
+                                   :modifiable => true)
+  end
+
+  def edit
+    @title = "Edit Survey Section"
+    @survey_section = SurveySection.find(params[:id])
+  end
+
+  def create
+    survey = Survey.find(params[:survey_section][:survey_id])
+    SurveySection.where(:survey_id => survey.id)
+                 .where("display_order >= ?", params[:survey_section][:display_order])
+                 .update_all("display_order = display_order+1")
+    @survey_section = survey.survey_sections.build(survey_section_params)
+    @survey_section.display_order = params[:survey_section][:display_order].to_i
+    #@survey_section.questions.build(:text=>'New question',:pick=>'none',:display_order=>0,:display_type=>'default').answers.build(:text=>'string', :response_class=>'string', :display_order=>1, :template=>true)
+    if @survey_section.save
+      redirect_to :back
+    else
+      render :action => 'new', :layout => 'surveyor_gui/surveyor_gui_blank'
+    end
+  end
+
+  def update
+    @title = "Update Survey Section"
+    @survey_section = SurveySection.find(params[:id])
+    if @survey_section.update_attributes(survey_section_params)
+      render :blank, :layout => 'surveyor_gui/surveyor_gui_blank'
+    else
+      render :action => 'edit', :layout => 'surveyor_gui/surveyor_gui_blank'
+    end
+  end
+
+  def destroy
+    @survey_section = SurveySection.find(params[:id])
+    if !@survey_section.survey.template && @survey_section.survey.response_sets.count > 0
+      render :text => "Reponses have already been collected for this survey, therefore it cannot be modified. Please create a new survey instead."
+      return false
+    end
+    if !@survey_section.modifiable
+      render :text => "This section cannot be removed."
+      return false
+    end
+    if !@survey_section.questions.map{|q| q.dependency_conditions}.flatten.blank?
+      render :text => "The following questions have logic that depend on questions in this section: \n\n"+@survey_section.questions.map{|q| q.dependency_conditions.map{|d| " - "+d.dependency.question.text}}.flatten.join('\n')+"\n\nPlease delete logic before deleting this section.".html_safe
+      return
+    end
+    @survey_section.destroy
+    render :text => ""
+  end
+
+  def sort
+    survey = Survey.find(params[:survey_id])
+    satts = { :id => params[:survey_id], :survey_sections_attributes=>{} }
+    sections = params[:survey_section]
+    sections.each_with_index do |sid, index|
+      satts[:survey_sections_attributes][index.to_s] = { :id => sid, :display_order => index }
+    end
+    puts satts
+    survey.update_attributes!(satts)
+    render :nothing => true
+  end
+
+  private
+  def survey_section_params
+    ::PermittedParams.new(params[:survey_section]).survey_section
+  end
+
+end

data/app/controllers/surveyor_gui/surveyforms_controller.rb

@@ -0,0 +1,4 @@
+class SurveyorGui::SurveyformsController < ApplicationController
+  include Surveyor::SurveyorControllerMethods
+  include SurveyorGui::SurveyformsControllerMethods
+end

data/app/facades/report_formatter.rb

@@ -0,0 +1,46 @@
+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.to_f 
+    elsif [:date, :datetime, :time].include? @question.question_type_id 
+      format_time_stat(stat.to_f)
+    else
+      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/surveyor_gui/application_helper.rb

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

data/app/helpers/surveyor_gui/dependencys_helper.rb

@@ -0,0 +1,5 @@
+module SurveyorGui::DependencysHelper
+  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/surveyor_gui/question_groups_helper.rb

@@ -0,0 +1,3 @@
+module SurveyorGui::QuestionGroupsHelper
+  include SurveyorGui::QuestionsHelper
+end

data/app/helpers/surveyor_gui/questions_helper.rb

@@ -0,0 +1,22 @@
+module SurveyorGui::QuestionsHelper
+  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/surveyor_gui/reports_helper.rb

@@ -0,0 +1,19 @@
+module SurveyorGui::ReportsHelper
+
+  def question_should_display(q)
+    display=true
+    if q.dependency
+      q.dependency.dependency_conditions.each do |dc|
+        if Response.where(:question_id => dc.question_id).first && dc.answer_id != Response.where(:question_id => dc.question_id).first.answer_id
+          display=false
+        end
+      end
+    end
+    return display
+  end
+  
+  def star_average(responses,q)
+    (responses.where(:question_id => q.id).where('integer_value > ?',0).collect(&:integer_value).average * 2).round
+  end
+
+end

data/app/helpers/surveyor_gui/surveyforms_helper.rb

@@ -0,0 +1,164 @@
+module SurveyorGui
+  module SurveyformsHelper
+    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, :answer]
+                }
+              },
+              {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
+end
+