helena 0.3.3

data/app/models/helena/answer.rb

@@ -0,0 +1,48 @@
+module Helena
+  class Answer
+    include Helena::Concerns::ApplicationModel
+
+    field :code,        type: String
+    field :ip_address,  type: String
+    field :created_at,  type: DateTime, default: -> { DateTime.now }
+
+    embedded_in :session, inverse_of: :answers
+
+    validates :code, :ip_address, presence: true
+    validates :code, uniqueness: true
+
+    def self.build_generic(code, value, ip_address)
+      value = cast_value(value)
+      answer_class_for(value).new(code: code, value: value, ip_address: ip_address)
+    end
+
+    def self.answer_class_for(value)
+      case value
+      when Fixnum
+        Helena::IntegerAnswer
+      when TrueClass
+        Helena::BooleanAnswer
+      when FalseClass
+        Helena::BooleanAnswer
+      when String
+        Helena::StringAnswer
+      end
+    end
+
+    def self.cast_value(value)
+      if value == 'true'
+        true
+      elsif value == 'false'
+        false
+      elsif integer?(value)
+        value.to_i
+      else
+        value.to_s
+      end
+    end
+
+    def self.integer?(str)
+      Integer(str) rescue false
+    end
+  end
+end

data/app/models/helena/boolean_answer.rb

@@ -0,0 +1,5 @@
+module Helena
+  class BooleanAnswer < Answer
+    field :value, type: Boolean
+  end
+end

data/app/models/helena/concerns/application_model.rb

@@ -0,0 +1,19 @@
+module Helena
+  module Concerns
+    module  ApplicationModel
+      extend ActiveSupport::Concern
+
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      included do
+        before_destroy :removable?
+
+        # Removable is given by default. Override for custom behaviour
+        def removable?
+          true
+        end
+      end
+    end
+  end
+end

data/app/models/helena/concerns/questions/requirable.rb

@@ -0,0 +1,19 @@
+module Helena
+  module Concerns
+    module Questions
+      module Requirable
+        extend ActiveSupport::Concern
+
+        included do
+          field :required, type: Boolean, default: false
+        end
+
+        def validate_answers_in(answers)
+          errors = {}
+          errors[code] = :blank if answers[code].blank? && required
+          errors
+        end
+      end
+    end
+  end
+end

data/app/models/helena/concerns/questions/validates_one_label.rb

@@ -0,0 +1,22 @@
+module Helena
+  module Concerns
+    module Questions
+      module ValidatesOneLabel
+        extend ActiveSupport::Concern
+
+        included do
+          validate :labels_preselection
+        end
+
+        private
+
+        def labels_preselection
+          selected_labels = labels.select { |label| label.preselected == true }
+          return if selected_labels.size <= 1
+          selected_labels.each { |label| label.errors.add(:preselected, I18n.t(:taken, scope: 'activerecord.errors.messages')) }
+          errors.add(:labels, I18n.t('helena.admin.radio_group.only_one_preselection_allowed'))
+        end
+      end
+    end
+  end
+end

data/app/models/helena/integer_answer.rb

@@ -0,0 +1,5 @@
+module Helena
+  class IntegerAnswer < Answer
+    field :value, type: Integer
+  end
+end

data/app/models/helena/label.rb

@@ -0,0 +1,18 @@
+module Helena
+  class Label
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable
+
+    field :text,        type: String
+    field :value,       type: String
+    field :preselected, type: Boolean, default: false
+
+    embedded_in :question, inverse_of: :labels
+
+    orderable
+
+    validates :text, presence: true
+    validates :value, presence: true
+    validates :value, uniqueness: true
+  end
+end

data/app/models/helena/question.rb

@@ -0,0 +1,63 @@
+module Helena
+  class Question
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable
+
+    CODE_FORMAT = /\A[a-z]([-\w]{,498}[a-z\d])?\Z/
+
+    TYPES = [
+      Helena::Questions::ShortText,
+      Helena::Questions::LongText,
+      Helena::Questions::StaticText,
+      Helena::Questions::RadioGroup,
+      Helena::Questions::CheckboxGroup,
+      Helena::Questions::RadioMatrix
+    ]
+
+    embedded_in :question_group, inverse_of: :questions
+
+    embeds_many :labels, class_name: 'Helena::Label'
+    embeds_many :sub_questions, class_name: 'Helena::SubQuestion'
+
+    accepts_nested_attributes_for :labels, allow_destroy: true, reject_if: :reject_labels
+    accepts_nested_attributes_for :sub_questions, allow_destroy: true, reject_if: :reject_sub_questions
+
+    field :code,          type: String
+    field :question_text, type: String
+
+    orderable
+
+    validates :code, presence: true
+
+    # consist of lowercase characters or digits, not starting with a digit or underscore and not ending with an underscore
+    # foo_32: correct, 32_foo: incorrect, _bar: incorrect, bar_: incorrect, FooBaar: incorrect
+    validates :code, format: { with: CODE_FORMAT }
+    validate :uniqueness_of_code
+
+    def includes_labels?
+      false
+    end
+
+    def includes_subquestions?
+      false
+    end
+
+    private
+
+    def uniqueness_of_code
+      question_code_occurences = question_group.version.question_code_occurences
+      errors.add :code, :taken if question_code_occurences[code] > 1
+    end
+
+    def reject_labels(attributed)
+      attributed['text'].blank? &&
+          attributed['value'].blank?
+    end
+
+    def reject_sub_questions(attributed)
+      attributed['code'].blank? &&
+          attributed['default_value'].blank? &&
+          attributed['question_text'].blank?
+    end
+  end
+end

data/app/models/helena/question_group.rb

@@ -0,0 +1,18 @@
+module Helena
+  class QuestionGroup
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable
+
+    embedded_in :version
+
+    embeds_many :questions, class_name: 'Helena::Question'
+
+    orderable
+
+    field :title, type: String
+
+    def question_codes
+      questions.map { |question| [question.code] +  question.sub_questions.map(&:code) }.flatten
+    end
+  end
+end

data/app/models/helena/questions/checkbox_group.rb

@@ -0,0 +1,17 @@
+module Helena
+  module Questions
+    class CheckboxGroup < Helena::Question
+      include Helena::Concerns::Questions::Requirable
+
+      def includes_subquestions?
+        true
+      end
+
+      def validate_answers_in(answers)
+        errors = {}
+        errors[code] = :blank if sub_questions.map { |sub_question| answers[sub_question.code] == 0 }.all? && required
+        errors
+      end
+    end
+  end
+end

data/app/models/helena/questions/long_text.rb

@@ -0,0 +1,9 @@
+module Helena
+  module Questions
+    class LongText < Helena::Question
+      include Helena::Concerns::Questions::Requirable
+
+      field :default_value, type: String
+    end
+  end
+end

data/app/models/helena/questions/radio_group.rb

@@ -0,0 +1,12 @@
+module Helena
+  module Questions
+    class RadioGroup < Helena::Question
+      include Helena::Concerns::Questions::Requirable
+      include Helena::Concerns::Questions::ValidatesOneLabel
+
+      def includes_labels?
+        true
+      end
+    end
+  end
+end

data/app/models/helena/questions/radio_matrix.rb

@@ -0,0 +1,24 @@
+module Helena
+  module Questions
+    class RadioMatrix < Helena::Question
+      include Helena::Concerns::Questions::Requirable
+      include Helena::Concerns::Questions::ValidatesOneLabel
+
+      def includes_labels?
+        true
+      end
+
+      def includes_subquestions?
+        true
+      end
+
+      def validate_answers_in(answers)
+        errors = {}
+        sub_questions.each do |sub_question|
+          errors[sub_question.code] = :blank if answers[sub_question.code].blank? && required
+        end
+        errors
+      end
+    end
+  end
+end

data/app/models/helena/questions/short_text.rb

@@ -0,0 +1,9 @@
+module Helena
+  module Questions
+    class ShortText < Helena::Question
+      include Helena::Concerns::Questions::Requirable
+
+      field :default_value, type: String
+    end
+  end
+end

data/app/models/helena/questions/static_text.rb

@@ -0,0 +1,7 @@
+module Helena
+  module Questions
+    class StaticText < Helena::Question
+      field :default_value, type: String
+    end
+  end
+end

data/app/models/helena/session.rb

@@ -0,0 +1,76 @@
+module Helena
+  class Session
+    include Helena::Concerns::ApplicationModel
+
+    field :token, type: String
+    field :view_token, type: String
+    field :completed, type: Boolean, default: false
+
+    belongs_to :survey, inverse_of: :sessions, class_name: 'Helena::Survey'
+    belongs_to :version, inverse_of: :sessions, class_name: 'Helena::Version'
+
+    embeds_many :answers, inverse_of: :session, class_name: 'Helena::Answer'
+
+    validates :token, :view_token, uniqueness: true
+
+    before_create :reset_tokens
+
+    def reset_tokens
+      # NOTE: there are (2*26+10)^k tokens available
+      # To not run into performance issues we could pregenerate unique tokens in the future
+      self.token = generate_token(5) until unique_token_for?
+      self.view_token = generate_token(25) until unique_token_for?(:view_token)
+    end
+
+    def self.to_csv
+      CSV.generate do |csv|
+        csv << fields.keys + uniq_answer_codes
+        all.each do |session|
+          csv << session.attributes.values_at(*fields.keys) + answer_values_in(session)
+        end
+      end
+    end
+
+    def as_json(options)
+      session = super(options)
+      session[:answer] = answers_as_hash
+      session
+    end
+
+    def answers_as_hash
+      answers.map { |answer| [answer[:code], answer[:value]] }.to_h
+    end
+
+    private
+
+    def self.answer_values_in(session)
+      answers = []
+      answer_codes.each do |code|
+        answers << session.answers.where(code: code).first.try(&:value)
+      end
+      answers
+    end
+
+    def self.answer_codes
+      answer_codes = []
+      all.each do |session|
+        answer_codes += session.answers.map(&:code) - answer_codes
+      end
+      answer_codes
+    end
+
+    def self.uniq_answer_codes
+      answer_codes.map do |code|
+        fields.keys.include?(code) ? "answer_#{code}" : code
+      end
+    end
+
+    def generate_token(size)
+      SecureRandom.base64(size).delete('/+=')[0, size]
+    end
+
+    def unique_token_for?(field = :token)
+      self.class.where(field => send(field)).blank? && send(field).present?
+    end
+  end
+end

data/app/models/helena/string_answer.rb

@@ -0,0 +1,5 @@
+module Helena
+  class StringAnswer < Answer
+    field :value, type: String
+  end
+end

data/app/models/helena/sub_question.rb

@@ -0,0 +1,27 @@
+module Helena
+  class SubQuestion
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable
+
+    field :text,        type: String
+    field :value,       type: String
+    field :code,        type: String
+    field :preselected, type: Boolean
+
+    embedded_in :question, inverse_of: :sub_questions
+
+    orderable
+
+    validates :code, format: { with: Helena::Question::CODE_FORMAT }
+    validate :uniqueness_of_code
+    validates :text, presence: true, uniqueness: true
+
+    def uniqueness_of_code
+      question_code_occurences = question.question_group.version.question_code_occurences
+
+      return true if question_code_occurences[code] <= 1
+
+      errors.add(:code, :taken, value: code)
+    end
+  end
+end

data/app/models/helena/survey.rb

@@ -0,0 +1,29 @@
+module Helena
+  class Survey
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable
+    include Mongoid::Document::Taggable
+
+    orderable
+
+    field :name,        type: String
+    field :language,    type: String
+    field :description, type: String
+
+    embeds_many :versions, inverse_of: :survey, class_name: 'Helena::Version'
+    has_many :sessions, inverse_of: :survey, dependent: :destroy, class_name: 'Helena::Session'
+
+    accepts_nested_attributes_for :versions
+
+    validates :name, presence: true, uniqueness: true
+    validates :language, presence: true
+
+    def draft_version
+      versions.find_by version: 0
+    end
+
+    def newest_version
+      versions.find_by version: versions.max(:version)
+    end
+  end
+end

data/app/models/helena/survey_detail.rb

@@ -0,0 +1,10 @@
+module Helena
+  class SurveyDetail
+    include Helena::Concerns::ApplicationModel
+
+    field :title, type: String
+    field :description, type: String
+
+    embedded_in :version, inverse_of: :survey_detail
+  end
+end

data/app/models/helena/version.rb

@@ -0,0 +1,33 @@
+module Helena
+  class Version
+    include Helena::Concerns::ApplicationModel
+    include Mongoid::Orderable # Needed, because the embedded objects needs this, see
+
+    field :version,        type: Integer, default: 0
+    field :notes,          type: String
+    field :session_report, type: String
+
+    embedded_in :survey
+
+    embeds_many :question_groups, class_name: 'Helena::QuestionGroup'
+    embeds_many :sessions, class_name: 'Helena::Session'
+
+    embeds_one :survey_detail, class_name: 'Helena::SurveyDetail'
+
+    accepts_nested_attributes_for :survey_detail
+    accepts_nested_attributes_for :question_groups
+
+    scope :without_base, -> { where(:version.gt => 0) }
+
+    validates :version, presence: true
+    validates :version, uniqueness: { scope: :survey_id }
+
+    def question_codes
+      question_groups.map(&:question_codes).flatten
+    end
+
+    def question_code_occurences
+      question_codes.each_with_object(Hash.new(0)) { |word, counts| counts[word] += 1 }
+    end
+  end
+end

data/app/views/helena/admin/question_groups/_form.html.haml

@@ -0,0 +1,3 @@
+= simple_form_for [:admin, @survey, @question_group] do |f|
+  = f.input :title
+  = f.submit t('shared.save'), class: 'btn btn-success'

data/app/views/helena/admin/question_groups/edit.html.haml

@@ -0,0 +1,3 @@
+.helena-admin
+  %h2= t 'shared.edit'
+  = render 'form'

data/app/views/helena/admin/question_groups/index.html.haml

@@ -0,0 +1,41 @@
+.helena-admin
+  %h2
+    = Helena::QuestionGroup.model_name.human(count: 2)
+    = "(#{@question_groups.count})"
+  - if @question_groups.empty?
+    .alert.alert-warning
+      = t '.empty'
+  - else
+    .table-responsive
+      %table.table.question_groups
+        %thead
+          %tr
+            %th.position= Helena::QuestionGroup.human_attribute_name(:position)
+            %th= Helena::QuestionGroup.human_attribute_name(:title)
+            %th
+        %tbody
+          - @question_groups.each do |question_group|
+            %tr[question_group]
+              %td.position
+                = question_group.position
+              %td.title
+                = question_group.title
+              %td
+                .btn-group.btn-group-sm
+                  - unless question_group.last?
+                    = link_to move_down_admin_survey_question_group_path(@survey, question_group), class: 'btn btn-primary',
+                                                                                                   method: :patch,
+                                                                                                   title: t('shared.move_down')  do
+                      %i.glyphicon.glyphicon-chevron-down
+                  - unless question_group.first?
+                    = link_to move_up_admin_survey_question_group_path(@survey, question_group), class: 'btn btn-primary',
+                                                                                                 method: :patch,
+                                                                                                 title: t('shared.move_up')  do
+                      %i.glyphicon.glyphicon-chevron-up
+
+                  = link_to t('shared.edit'), edit_admin_survey_question_group_path(@survey, question_group), class: 'btn btn-primary'
+                  = link_to Helena::Question.model_name.human(count: 2), admin_survey_question_group_questions_path(@survey, question_group), class: 'btn btn-primary'
+                  = link_to t('shared.delete'), admin_survey_question_group_path(@survey, question_group), method: :delete, class: 'btn btn-danger', data: { confirm: t('shared.delete_question') }
+
+  %a.btn.btn-success{ href:  new_admin_survey_question_group_path}
+    = t '.add'

data/app/views/helena/admin/question_groups/new.html.haml

@@ -0,0 +1,3 @@
+.helena-admin
+  %h2= t '.new'
+  = render 'form'

data/app/views/helena/admin/questions/_form.html.haml

@@ -0,0 +1,15 @@
+= simple_form_for [:admin, @survey, @question_group, @question] do |f|
+  = f.input :question_text
+  = f.input :code, hint: t('shared.code_hint')
+  = f.input :_type, collection: Helena::Question::TYPES.map { |type| [type.model_name.human, type] }
+  - if @question.respond_to? :required
+    = f.input :required, as: :boolean
+  - if @question.is_a?(Helena::Questions::LongText) || @question.is_a?(Helena::Questions::StaticText)
+    = f.input :default_value
+  - if @question.is_a?(Helena::Questions::ShortText)
+    = f.input :default_value, as: :string
+  - if @question.includes_labels?
+    = render 'labels', form: f
+  - if @question.includes_subquestions?
+    = render 'sub_questions', form: f
+  = f.submit t('shared.save'), class: 'btn btn-success'

data/app/views/helena/admin/questions/_labels.html.haml

@@ -0,0 +1,24 @@
+%h3= t '.labels'
+.table-responsive
+  %table.table.labels
+    %thead
+      %tr
+        %th.position= Helena::Label.human_attribute_name :position
+        %th.preselected
+        %th.text= Helena::Label.human_attribute_name :text
+        %th.value= Helena::Label.human_attribute_name :value
+        %th.delete
+    %tbody
+      = form.simple_fields_for :labels  do |label|
+        %tr[label.object]
+          %td.position
+            = label.input :position, as: :integer, label: false
+          %td.preselected
+            = label.input :preselected, as: :boolean, label: Helena::Label.human_attribute_name(:preselected)
+          %td.text
+            = label.input :text, label: false
+          %td.value
+            = label.input :value, label: false
+          %td.delete
+            - unless label.object.new_record?
+              = label.input :_destroy, as: :boolean, label: Helena::Label.human_attribute_name(:_destroy)

data/app/views/helena/admin/questions/_sub_questions.html.haml

@@ -0,0 +1,32 @@
+%h3= t '.options'
+.table-responsive
+  %table.table.sub_questions
+    %thead
+      %tr
+        %th.position= Helena::SubQuestion.human_attribute_name :position
+        %th.position= Helena::SubQuestion.human_attribute_name :code
+        - if @question.is_a?(Helena::Questions::CheckboxGroup)
+          %th.preselected
+        %th.text= Helena::SubQuestion.human_attribute_name :text
+        - if @question.is_a?(Helena::Questions::CheckboxGroup)
+          %th.value= Helena::SubQuestion.human_attribute_name :value
+        %th.delete
+    %tbody
+      = form.simple_fields_for :sub_questions  do |sub_question|
+        %tr[sub_question.object]
+          %td.position
+            = sub_question.input :position, as: :integer, label: false
+          %td.code
+            = sub_question.input :code, label: false, hint: t('shared.code_hint')
+          - if @question.is_a?(Helena::Questions::CheckboxGroup)
+            %td.preselected
+              = sub_question.input :preselected, as: :boolean
+          %td.text
+            = sub_question.input :text, label: false
+          - if @question.is_a?(Helena::Questions::CheckboxGroup)
+            %td.value
+              = sub_question.input :value, label: false, as: :hidden, value: 1
+          %td.delete
+            - unless sub_question.object.new_record?
+              = sub_question.input :_destroy, as:    :boolean,
+                                              label: Helena::SubQuestion.human_attribute_name(:_destroy)

data/app/views/helena/admin/questions/edit.html.haml

@@ -0,0 +1,3 @@
+.helena-admin
+  %h2= t 'shared.edit'
+  = render 'form'