surveillance 0.1.1

data/app/controllers/surveillance/response/partial_attempts_controller.rb

@@ -0,0 +1,15 @@
+module Surveillance
+  module Response
+    class PartialAttemptsController < Surveillance::Response::BaseController
+      def update
+        if attempt.save
+          head 200
+        else
+          render status: 422, json: {
+            errors: attempt.errors.messages
+          }
+        end
+      end
+    end
+  end
+end

data/app/controllers/surveillance/surveys_controller.rb

@@ -0,0 +1,6 @@
+module Surveillance
+  class SurveysController < Surveillance::ApplicationController
+    expose(:surveys) { Surveillance::Survey.published }
+    expose(:survey, model: Surveillance::Survey)
+  end
+end

data/app/helpers/surveillance/admin/exports_helper.rb

@@ -0,0 +1,37 @@
+module Surveillance
+  module Admin
+    module ExportsHelper
+      def initialize_formats
+        @formats = {
+          black_background: Spreadsheet::Format.new(
+            color: :white,
+            size: 10,
+            align: :left,
+            border: :thin,
+            pattern: 1,
+            pattern_fg_color: :black
+          ),
+          gray: Spreadsheet::Format.new(
+            color: :white,
+            size: 10,
+            align: :left,
+            border: :thin,
+            pattern: 1,
+            pattern_fg_color: :gray
+          ),
+          border: Spreadsheet::Format.new(border: :thin),
+          bold: Spreadsheet::Format.new(weight: :bold)
+        }
+      end
+
+      # Format helper
+      def set_format row, range, format
+        @formats || initialize_formats
+        # Assume int if `range` is not a Range
+        range = (range..range) unless range.instance_of? Range
+        # Set format to specified cells
+        range.each { |n| @sheet.row(row).set_format(n, @formats[format]) }
+      end
+    end
+  end
+end

data/app/helpers/surveillance/application_helper.rb

@@ -0,0 +1,84 @@
+module Surveillance
+  module ApplicationHelper
+    # Renders a form field for the given question
+    def survey_field_for builder, question, index
+      question.field.attempt = builder.object
+
+      field = capture do
+        render partial: question.field.form_path, locals: {
+          f: builder, question: question, question_index: index
+        }
+      end
+
+      content_tag :div, field, class: "surveillance-question", data: {
+        "branch-rules" => branch_rules_for(question),
+        "view" => question.field.view_name,
+        "question-id" => question.id,
+        "required" => question.mandatory
+      }
+    end
+
+    def branch_rules_for question
+      question.branch_rules.to_json
+    end
+
+    # Renders an answer result
+    def survey_answer_for attempt, question
+      question.field(attempt: attempt, answer: attempt.answer_to(question))
+
+      render partial: question.field.show_path, locals: { question: question }
+    end
+
+    def settings_fields_for builder, question
+      render partial: question.field.settings_path, locals: {
+        f: builder, question: question
+      } if question.field.settings?
+    end
+
+    def survey_overview_for question
+      render partial: question.field.overview_path, locals: {
+        question: question
+      }
+    end
+
+    def link_to_add_fields label, target, options = {}
+      builder = options.fetch(:builder, nil)
+      relation = options.fetch(:relation, nil)
+      # Get class name from builder's object class relations list
+      class_name = builder.object.class.reflections[relation].class_name
+      # Build new associated object
+      object = class_name.constantize.new
+      id = object.object_id
+
+      partial_path = options.delete(:partial) || "#{ relation }_fields"
+
+      fields = builder.fields_for(relation, object, child_index: id) do |f|
+        locals = { f: f }
+        locals.reverse_merge!(options[:locals]) if options[:locals]
+
+        render partial: partial_path, locals: locals
+      end
+
+      link_to label.html_safe, target, class: "btn btn-primary", data: {
+        id: id, fields: fields.gsub("\n", ""), toggle: "new-field"
+      }
+    end
+
+    def question_options_for_select question
+      options_for_select(
+        question.options.map { |option| [option.title, option.id] }
+      )
+    end
+
+    def setting_field_for question, key, type, builder
+      setting = question.field.settings[key]
+
+      render(
+        partial: "surveillance/field/shared/settings/#{ type.to_s }",
+        locals: {
+          question: question, key: key, f: builder, setting: setting
+        }
+      )
+    end
+  end
+end

data/app/models/surveillance/answer.rb

@@ -0,0 +1,56 @@
+module Surveillance
+  class Answer < ActiveRecord::Base
+    belongs_to :attempt, class_name: "Surveillance::Attempt", inverse_of: :answers
+    belongs_to :question, class_name: "Surveillance::Question"
+
+    has_and_belongs_to_many :options, class_name: "Surveillance::Option",
+      join_table: "surveillance_answers_options"
+
+    has_one :content, class_name: "Surveillance::AnswerContent",
+      foreign_key: :answer_id
+    accepts_nested_attributes_for :content,
+      reject_if: :optional_content_not_filled?
+
+    validates_presence_of :question_id
+    validates_with Surveillance::Validators::AnswerValidator
+
+    def option
+      options.first
+    end
+
+    def option_id
+      option_ids.first
+    end
+
+    def option_id=(id)
+      self.option_ids = [id]
+    end
+
+    def option_ids=(ids)
+      ids = ids.reduce([]) do |ids_list, id|
+        case id
+        when "other" then self.other_choosed = true
+        when /^\d+$/ then ids_list << id
+        end
+        ids_list
+      end
+
+      options.clear if options.length > 0
+      super(ids)
+    end
+
+    def content_or_build
+      content || build_content
+    end
+
+    def optional_content_not_filled? attributes
+      question.field.answer = self
+
+      if question.field.mandatory_content?
+        (!question.mandatory && (!attributes["value"].presence))
+      else
+        !attributes["value"].presence
+      end
+    end
+  end
+end

data/app/models/surveillance/answer_content.rb

@@ -0,0 +1,7 @@
+module Surveillance
+  class AnswerContent < ActiveRecord::Base
+    belongs_to :answer, class_name: "Surveillance::Answer"
+
+    validates_presence_of :value
+  end
+end

data/app/models/surveillance/attempt.rb

@@ -0,0 +1,146 @@
+module Surveillance
+  class Attempt < ActiveRecord::Base
+    include AASM
+
+    has_many :answers, class_name: "Surveillance::Answer",
+      foreign_key: 'attempt_id', dependent: :destroy, inverse_of: :attempt,
+      before_add: :set_attempt_on_answers
+    accepts_nested_attributes_for :answers
+
+    belongs_to :survey, class_name: "Surveillance::Survey",
+               inverse_of: :attempts
+
+    belongs_to :user, polymorphic: true
+
+    scope :includes_all, -> {
+      includes(answers: [:question, :options, :content])
+    }
+
+    before_validation :ensure_access_token
+    before_validation :filter_required_answers
+    before_save :fill, if: :answers_filled_and_empty?
+
+    aasm column: :state do
+      state :empty, initial: true
+      state :partially_filled
+      state :completed
+
+      event :fill do
+        transitions from: [:empty, :partially_filled], to: :partially_filled
+      end
+
+      event :complete do
+        transitions from: [:empty, :partially_filled, :completed], to: :completed
+      end
+    end
+
+    def state_label
+      if partially_filled?
+        [
+          I18n.t("surveillance.attempts.states.#{ state_name }"),
+          I18n.t("surveillance.attempts.step", step: last_answered_section + 1),
+        ].join(" - ")
+      else
+        I18n.t("surveillance.attempts.states.#{ state_name }")
+      end
+    end
+
+    def fill_section(index, attributes)
+      self.last_answered_section = index.to_i
+      update_attributes(attributes)
+    end
+
+    def sections_to_answer
+      @sections_to_answer ||= build_sections_to_answer_hash
+    end
+
+    def answer_to(question)
+      id = question.kind_of?(Integer) ? question : question.id
+      questions_answers[id]
+    end
+
+    def questions_answers
+      @questions_answers ||= Hash[answers.map { |a| [a.question_id, a] }]
+    end
+
+    def to_param
+      access_token
+    end
+
+    def answers_attributes=(attributes)
+      processed = attributes.each_with_object({}) do |(key, val), hash|
+        if val[:id].blank? && (answer = answer_to(val[:question_id].to_i))
+          val[:id] = answer.id
+        end
+
+        hash[key] = val
+      end
+
+      # Clear `@questions_answers` cache so next time we call questions_answers
+      # hash it will be fetched with latest data
+      @questions_answers = nil
+
+      assign_nested_attributes_for_collection_association(:answers, processed)
+    end
+
+    private
+
+    def set_attempt_on_answers(answer)
+      answer.attempt = self
+    end
+
+    def answers_filled_and_empty?
+      empty? && answers.length > 0
+    end
+
+    def ensure_access_token
+      self.access_token ||= Surveillance.unique_token
+    end
+
+    def filter_required_answers
+      answers_to_delete = answers.reduce([]) do |delete, answer|
+        delete << answer unless sections_to_answer[answer.question.section.id]
+        delete
+      end
+
+      answers_to_delete.each { |answer| answers.delete(answer) }
+    end
+
+    def build_sections_to_answer_hash
+      @sections = survey.sections.includes(questions: [:questions, :branch_rules])
+      @sections.limit(last_answered_section + 1) if last_answered_section
+
+      # Prepare sections to answer hash, with each section needing to be
+      # answered by default
+      sections_hash = Hash[@sections.map { |section| [section.id, true] }]
+      # Iterate on each section and check if a matching branching rule is found.
+      # If one is found, update the sections_hash according to the rule
+      @sections.each do |section|
+        next if sections_hash[section.id] == false
+
+        matching_rule = section.questions.reduce(nil) do |rule, question|
+          if !rule && (answer = answer_to(question))
+            rule = question.matching_rule_for(answer)
+          end
+
+          rule
+        end
+
+        if matching_rule
+          sections_hash.reduce(true) do |continue, (section_id, _)|
+            if continue && section.id == section_id
+              continue = false
+            elsif section_id == matching_rule.section_id
+              break
+            elsif !continue
+              sections_hash[section_id] = false
+            end
+            continue
+          end
+        end
+      end
+
+      sections_hash
+    end
+  end
+end

data/app/models/surveillance/branch_rule.rb

@@ -0,0 +1,52 @@
+module Surveillance
+  class BranchRule < ActiveRecord::Base
+    belongs_to :question
+    belongs_to :sub_question, class_name: "Surveillance::Question"
+    belongs_to :section
+    belongs_to :option
+
+    validates_presence_of :action, :condition
+
+    def finalize_survey?
+      action == "finalize_survey"
+    end
+
+    def goto_section?
+      action == "goto_section"
+    end
+
+    def as_json options = {}
+      attributes = [:condition, :action]
+      attributes += [:sub_question_id, :section_id, :option_id].select do |id|
+        send(id).presence
+      end
+      super(only: attributes)
+    end
+
+    def matches? answer
+      send(condition, answer)
+    end
+
+    def answers answer
+      field = answer.question.field
+      field.answer = answer
+      field.present?
+    end
+
+    def doesnt_answer answer
+      !answers(answer)
+    end
+
+    def answers_option answer
+      qid = sub_question_id || question_id
+
+      answer.options.any? do |option|
+        option.id == option_id && option.question_id == qid
+      end
+    end
+
+    def doesnt_answer_option answer
+      !answers_option(answer)
+    end
+  end
+end

data/app/models/surveillance/field_setting.rb

@@ -0,0 +1,6 @@
+module Surveillance
+  class FieldSetting < ActiveRecord::Base
+    belongs_to :question
+    validates_presence_of :key, :value, :question
+  end
+end

data/app/models/surveillance/option.rb

@@ -0,0 +1,18 @@
+module Surveillance
+  class Option < ActiveRecord::Base
+    has_and_belongs_to_many :answers, class_name: "Surveillance::Answer",
+      join_table: "surveillance_answers_options"
+
+    belongs_to :question, class_name: "Surveillance::Question"
+
+    validates_presence_of :title
+
+    scope :ordered, -> { order("surveillance_options.id ASC") }
+
+    def answers_for question
+      answers.select do |answer|
+        answer.question_id == question.id
+      end
+    end
+  end
+end

data/app/models/surveillance/question.rb

@@ -0,0 +1,50 @@
+module Surveillance
+  class Question < ActiveRecord::Base
+    include Surveillance::Field
+    include ActionView::Helpers::SanitizeHelper
+
+    has_many :questions, as: :parent, class_name: "Surveillance::Question",
+      inverse_of: :parent
+    accepts_nested_attributes_for :questions, allow_destroy: true
+
+    belongs_to :parent, polymorphic: true, inverse_of: :questions
+
+    has_many :options, -> { ordered }, class_name: "Surveillance::Option",
+      dependent: :destroy
+    accepts_nested_attributes_for :options, allow_destroy: :true
+
+    has_many :answers, class_name: "Surveillance::Answer", dependent: :destroy
+
+    has_many :settings, class_name: "Surveillance::FieldSetting",
+      dependent: :destroy, inverse_of: :question
+    accepts_nested_attributes_for :settings
+
+    has_many :branch_rules, class_name: "Surveillance::BranchRule",
+      dependent: :destroy, inverse_of: :question
+    accepts_nested_attributes_for :branch_rules, allow_destroy: :true
+
+    validates_presence_of :title
+
+    delegate :survey, to: :parent
+
+    scope :ordered, -> { order("surveillance_questions.id ASC") }
+
+    def matching_rule_for answer
+      branch_rules.find { |rule| rule.matches?(answer) }
+    end
+
+    def section
+      parent_type == "Surveillance::Question" ? parent.parent : parent
+    end
+
+    def column_header
+      header = if field.matrix? && field.display_other_field?(self)
+        title + " - #{ field.settings.other.label }"
+      else
+        title
+      end
+
+      sanitize(header, tags: [])
+    end
+  end
+end