unique_rapidfire 1.0.0

data/app/helpers/rapidfire/application_helper.rb

@@ -0,0 +1,12 @@
+module Rapidfire
+  module ApplicationHelper
+    def render_answer_form_helper(answer, form)
+      partial = answer.question.type.to_s.split("::").last.downcase
+      render partial: "rapidfire/answers/#{partial}", locals: { f: form, answer: answer }
+    end
+
+    def checkbox_checked?(answer, option)
+      answer.answer_text.to_s.split(",").include?(option)
+    end
+  end
+end

data/app/models/rapidfire/answer.rb

@@ -0,0 +1,18 @@
+module Rapidfire
+  class Answer < ActiveRecord::Base
+    belongs_to :question
+    belongs_to :answer_group, inverse_of: :answers
+
+    validates :question, :answer_group, presence: true
+    validate  :verify_answer_text, :if => "question.present?"
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :question_id, :answer_group, :answer_text
+    end
+
+    private
+    def verify_answer_text
+      question.validate_answer(self)
+    end
+  end
+end

data/app/models/rapidfire/answer_group.rb

@@ -0,0 +1,12 @@
+module Rapidfire
+  class AnswerGroup < ActiveRecord::Base
+    belongs_to :question_group
+    belongs_to :user, polymorphic: true
+    has_many   :answers, inverse_of: :answer_group, autosave: true
+    validates :unique_id, :uniqueness => {:scope => :question_group}
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :question_group, :user, :unique_id
+    end
+  end
+end

data/app/models/rapidfire/question.rb

@@ -0,0 +1,44 @@
+module Rapidfire
+  class Question < ActiveRecord::Base
+    belongs_to :question_group, :inverse_of => :questions
+    has_many   :answers
+
+    default_scope { order(:position) }
+
+    validates :question_group, :question_text, :presence => true
+    serialize :validation_rules
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :question_group, :question_text, :validation_rules, :answer_options
+    end
+
+    def self.inherited(child)
+      child.instance_eval do
+        def model_name
+          Question.model_name
+        end
+      end
+
+      super
+    end
+
+    def rules
+      validation_rules || {}
+    end
+
+    # answer will delegate its validation to question, and question
+    # will inturn add validations on answer on the fly!
+    def validate_answer(answer)
+      if rules[:presence] == "1"
+        answer.validates_presence_of :answer_text
+      end
+
+      if rules[:minimum].present? || rules[:maximum].present?
+        min_max = { minimum: rules[:minimum].to_i }
+        min_max[:maximum] = rules[:maximum].to_i if rules[:maximum].present?
+
+        answer.validates_length_of :answer_text, min_max
+      end
+    end
+  end
+end

data/app/models/rapidfire/question_group.rb

@@ -0,0 +1,10 @@
+module Rapidfire
+  class QuestionGroup < ActiveRecord::Base
+    has_many  :questions
+    validates :name, :presence => true
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :name
+    end
+  end
+end

data/app/models/rapidfire/questions/checkbox.rb

@@ -0,0 +1,21 @@
+module Rapidfire
+  module Questions
+    class Checkbox < Rapidfire::Question
+      validates :answer_options, :presence => true
+
+      def options
+        answer_options.split(/\r?\n/)
+      end
+
+      def validate_answer(answer)
+        super(answer)
+
+        if rules[:presence] == "1" || answer.answer_text.present?
+          answer.answer_text.split(",").each do |value|
+            answer.errors.add(:answer_text, :invalid) unless options.include?(value)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/rapidfire/questions/date.rb

@@ -0,0 +1,16 @@
+module Rapidfire
+  module Questions
+    class Date < Rapidfire::Question
+      def validate_answer(answer)
+        super(answer)
+
+        if rules[:presence] == "1" || answer.answer_text.present?
+          begin  ::Date.parse(answer.answer_text.to_s)
+          rescue ArgumentError => e
+            answer.errors.add(:answer_text, :invalid)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/rapidfire/questions/long.rb

@@ -0,0 +1,6 @@
+module Rapidfire
+  module Questions
+    class Long < Rapidfire::Question
+    end
+  end
+end

data/app/models/rapidfire/questions/numeric.rb

@@ -0,0 +1,21 @@
+module Rapidfire
+  module Questions
+    class Numeric < Rapidfire::Question
+      def validate_answer(answer)
+        super(answer)
+
+        if rules[:presence] == "1" || answer.answer_text.present?
+          gt_or_lt = {}
+          if rules[:greater_than_or_equal_to].present?
+            gt_or_lt[:greater_than_or_equal_to] = rules[:greater_than_or_equal_to].to_i
+          end
+          if rules[:less_than_or_equal_to].present?
+            gt_or_lt[:less_than_or_equal_to] = rules[:less_than_or_equal_to].to_i
+          end
+
+          answer.validates_numericality_of :answer_text, gt_or_lt
+        end
+      end
+    end
+  end
+end

data/app/models/rapidfire/questions/radio.rb

@@ -0,0 +1,6 @@
+module Rapidfire
+  module Questions
+    class Radio < Select
+    end
+  end
+end

data/app/models/rapidfire/questions/select.rb

@@ -0,0 +1,19 @@
+module Rapidfire
+  module Questions
+    class Select < Rapidfire::Question
+      validates :answer_options, :presence => true
+
+      def options
+        answer_options.split(/\r?\n/)
+      end
+
+      def validate_answer(answer)
+        super(answer)
+
+        if rules[:presence] == "1" || answer.answer_text.present?
+          answer.validates_inclusion_of :answer_text, :in => options
+        end
+      end
+    end
+  end
+end

data/app/models/rapidfire/questions/short.rb

@@ -0,0 +1,6 @@
+module Rapidfire
+  module Questions
+    class Short < Rapidfire::Question
+    end
+  end
+end

data/app/serializers/rapidfire/question_result_serializer.rb

@@ -0,0 +1,15 @@
+module Rapidfire
+  class QuestionResultSerializer < ActiveModel::Serializer
+    self.root = false
+
+    attributes :question_type, :question_text, :results
+
+    def question_type
+      object.question.type
+    end
+
+    def question_text
+      object.question.question_text
+    end
+  end
+end

data/app/services/rapidfire/answer_group_builder.rb

@@ -0,0 +1,48 @@
+module Rapidfire
+  class AnswerGroupBuilder < Rapidfire::BaseService
+    attr_accessor :user, :question_group, :questions, :answers, :params, :unique_id
+    
+    def initialize(params = {})
+      super(params)
+      build_answer_group
+    end
+
+    def to_model
+      @answer_group
+    end
+
+    def save!(options = {})
+      params.each do |question_id, answer_attributes|
+        if answer = @answer_group.answers.find { |a| a.question_id.to_s == question_id.to_s }
+          text = answer_attributes[:answer_text]
+          answer.answer_text =
+            text.is_a?(Array) ? strip_checkbox_answers(text).join(',') : text
+        end
+      end
+
+      @answer_group.save!(options)
+    end
+
+    def save(options = {})
+      save!(options)
+    rescue Exception => e
+      # repopulate answers here in case of failure as they are not getting updated
+      @answers = @question_group.questions.collect do |question|
+        @answer_group.answers.find { |a| a.question_id == question.id }
+      end
+      false
+    end
+
+    private
+    def build_answer_group  
+      @answer_group = AnswerGroup.new(user: user, question_group: question_group, unique_id: unique_id)
+      @answers = @question_group.questions.collect do |question|
+        @answer_group.answers.build(question_id: question.id)
+      end
+    end
+
+    def strip_checkbox_answers(text)
+      text.reject(&:blank?).reject { |t| t == "0" }
+    end
+  end
+end

data/app/services/rapidfire/base_service.rb

@@ -0,0 +1,21 @@
+module Rapidfire
+  class BaseService
+    if Rails::VERSION::MAJOR == 4
+      include ActiveModel::Model
+    else
+      extend  ActiveModel::Naming
+      include ActiveModel::Conversion
+      include ActiveModel::Validations
+
+      def persisted; false end
+
+      def initialize(params={})
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+
+        super()
+      end
+    end
+  end
+end

data/app/services/rapidfire/question_form.rb

@@ -0,0 +1,85 @@
+module Rapidfire
+  class QuestionForm < Rapidfire::BaseService
+    AVAILABLE_QUESTIONS =
+      [
+       Rapidfire::Questions::Checkbox,
+       Rapidfire::Questions::Date,
+       Rapidfire::Questions::Long,
+       Rapidfire::Questions::Numeric,
+       Rapidfire::Questions::Radio,
+       Rapidfire::Questions::Select,
+       Rapidfire::Questions::Short,
+      ]
+
+    QUESTION_TYPES = AVAILABLE_QUESTIONS.inject({}) do |result, question|
+      question_name = question.to_s.split("::").last
+      result[question_name] = question.to_s
+      result
+    end
+
+    attr_accessor :question_group, :question,
+      :type, :question_text, :answer_options, :answer_presence,
+      :answer_minimum_length, :answer_maximum_length,
+      :answer_greater_than_or_equal_to, :answer_less_than_or_equal_to
+
+    delegate :valid?, :errors, :id, :to => :question
+
+    def to_model
+      question
+    end
+
+    def initialize(params = {})
+      from_question_to_attributes(params[:question]) if params[:question]
+      super(params)
+      @question ||= question_group.questions.new
+    end
+
+    def save
+      @question.new_record? ? create_question : update_question
+    end
+
+    private
+    def create_question
+      klass = nil
+      if QUESTION_TYPES.values.include?(type)
+        klass = type.constantize
+      else
+        errors.add(:type, :invalid)
+        return false
+      end
+
+      @question = klass.create(to_question_params)
+    end
+
+    def update_question
+      @question.update_attributes(to_question_params)
+    end
+
+    def to_question_params
+      {
+        :question_group => question_group,
+        :question_text  => question_text,
+        :answer_options => answer_options,
+        :validation_rules => {
+          :presence => answer_presence,
+          :minimum  => answer_minimum_length,
+          :maximum  => answer_maximum_length,
+          :greater_than_or_equal_to => answer_greater_than_or_equal_to,
+          :less_than_or_equal_to    => answer_less_than_or_equal_to
+        }
+      }
+    end
+
+    def from_question_to_attributes(question)
+      self.type = question.type
+      self.question_group  = question.question_group
+      self.question_text   = question.question_text
+      self.answer_options  = question.answer_options
+      self.answer_presence = question.rules[:presence]
+      self.answer_minimum_length = question.rules[:minimum]
+      self.answer_maximum_length = question.rules[:maximum]
+      self.answer_greater_than_or_equal_to = question.rules[:greater_than_or_equal_to]
+      self.answer_less_than_or_equal_to    = question.rules[:less_than_or_equal_to]
+    end
+  end
+end

data/app/services/rapidfire/question_group_results.rb

@@ -0,0 +1,29 @@
+module Rapidfire
+  class QuestionGroupResults < Rapidfire::BaseService
+    attr_accessor :question_group
+
+    # extracts question along with results
+    # each entry will have the following:
+    # 1. question type and question id
+    # 2. question text
+    # 3. if aggregatable, return each option with value
+    # 4. else return an array of all the answers given
+    def extract
+      @question_group.questions.collect do |question|
+        results =
+          case question
+          when Rapidfire::Questions::Select, Rapidfire::Questions::Radio,
+            Rapidfire::Questions::Checkbox
+            answers = question.answers.map(&:answer_text).map { |text| text.split(',') }.flatten
+            answers.inject(Hash.new(0)) { |total, e| total[e] += 1; total }
+
+          when Rapidfire::Questions::Short, Rapidfire::Questions::Date,
+            Rapidfire::Questions::Long, Rapidfire::Questions::Numeric
+            question.answers.pluck(:answer_text)
+          end
+
+        QuestionResult.new(question: question, results: results)
+      end
+    end
+  end
+end

data/app/services/rapidfire/question_result.rb

@@ -0,0 +1,11 @@
+module Rapidfire
+  class QuestionResult < Rapidfire::BaseService
+    include ActiveModel::Serialization
+
+    attr_accessor :question, :results
+
+    def active_model_serializer
+      Rapidfire::QuestionResultSerializer
+    end
+  end
+end

data/app/views/rapidfire/answer_groups/new.html.erb

@@ -0,0 +1,11 @@
+<h2>Please answer these Questions</h2>
+<hr/>
+
+<%= form_for([@question_group, @answer_group_builder]) do |f| %>
+  <%- @answer_group_builder.answers.each do |answer| %>
+    <%= f.fields_for("#{answer.question.id}", answer) do |answer_form| %>
+      <%= render_answer_form_helper(answer, answer_form) %>
+    <% end %>
+  <% end %>
+  <%= f.submit "Save" %>
+<% end %>

data/app/views/rapidfire/answers/_checkbox.html.erb

@@ -0,0 +1,11 @@
+<%= render partial: "rapidfire/answers/errors", locals: {answer: answer} %>
+
+<%= f.label :answer_text, answer.question.question_text %>
+<%= f.fields_for :answer_text do |af| %>
+  <%- answer.question.options.each do |option| %>
+    <%= af.label option do %>
+      <%= af.check_box nil, { id: nil, checked: checkbox_checked?(answer, option) }, option %>
+      <%= option %>
+    <% end %>
+  <% end %>
+<% end %>