decidim-forms 0.20.1 → 0.23.1

data/app/helpers/decidim/forms/admin/questionnaire_answers_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # Custom helpers for questionnaire answers
+      #
+      module QuestionnaireAnswersHelper
+        def first_table_th(answer)
+          return translated_attribute answer.first_short_answer.question.body if answer.first_short_answer
+
+          t("session_token", scope: "decidim.forms.user_answers_serializer")
+        end
+
+        def first_table_td(answer)
+          return answer.first_short_answer.body if answer.first_short_answer
+
+          answer.session_token
+        end
+
+        def display_percentage(number)
+          number_to_percentage(number, precision: 0, strip_insignificant_zeros: true, locale: I18n.locale)
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/forms/export_questionnaire_answers_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    class ExportQuestionnaireAnswersJob < ApplicationJob
+      queue_as :default
+
+      def perform(user, title, answers)
+        return if user&.email.blank?
+        return if answers&.blank?
+
+        serializer = Decidim::Forms::UserAnswersSerializer
+        export_data = Decidim::Exporters::FormPDF.new(answers, serializer).export
+
+        ExportMailer.export(user, title, export_data).deliver_now
+      end
+    end
+  end
+end

data/app/models/decidim/forms/answer.rb

@@ -17,9 +17,6 @@ module Decidim
                dependent: :destroy,
                inverse_of: :answer
 
-      validates :body, presence: true, if: -> { question.mandatory_body? }
-      validates :choices, presence: true, if: -> { question.mandatory_choices? }
-
       validate :user_questionnaire_same_organization
       validate :question_belongs_to_questionnaire
 

data/app/models/decidim/forms/answer_choice.rb

@@ -10,6 +10,13 @@ module Decidim
       belongs_to :answer_option,
                  class_name: "AnswerOption",
                  foreign_key: "decidim_answer_option_id"
+
+      belongs_to :matrix_row,
+                 class_name: "QuestionMatrixRow",
+                 foreign_key: "decidim_question_matrix_row_id",
+                 optional: true
+
+      validates :matrix_row, presence: true, if: -> { answer.question.matrix? }
     end
   end
 end

data/app/models/decidim/forms/answer_option.rb

@@ -3,9 +3,23 @@
 module Decidim
   module Forms
     class AnswerOption < Forms::ApplicationRecord
+      include Decidim::TranslatableResource
+
       default_scope { order(arel_table[:id].asc) }
 
+      translatable_fields :body
+
       belongs_to :question, class_name: "Question", foreign_key: "decidim_question_id"
+
+      has_many :display_conditions,
+               class_name: "DisplayCondition",
+               foreign_key: "decidim_answer_option_id",
+               dependent: :nullify,
+               inverse_of: :answer_option
+
+      def translated_body
+        Decidim::Forms::AnswerOptionPresenter.new(self).translated_body
+      end
     end
   end
 end

data/app/models/decidim/forms/display_condition.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # The data store for a DisplayCondition in the Decidim::Forms component.
+    # A display condition is associated to two questions. :question is the question
+    # that we want to display or hide based on some conditions, and :condition_question
+    # is the question the answers of which are checked against the conditions.
+    # Conditions can be whether the question is answered ("answered") or it is not ("not_answered"),
+    # if the selected answer option is ("equal") or is not ("not_equal") a given one, or whethe
+    # the text value of the answer matches a string ("match").
+    class DisplayCondition < Forms::ApplicationRecord
+      enum condition_type: [:answered, :not_answered, :equal, :not_equal, :match], _prefix: true
+
+      # Question which will be displayed or hidden
+      belongs_to :question, class_name: "Question", foreign_key: "decidim_question_id", inverse_of: :display_conditions
+
+      # Question the answers of which are checked against conditions
+      belongs_to :condition_question, class_name: "Question", foreign_key: "decidim_condition_question_id", inverse_of: :display_conditions_for_other_questions
+
+      # Answer option provided to check for "equal" or "not_equal" (optional)
+      belongs_to :answer_option, class_name: "AnswerOption", foreign_key: "decidim_answer_option_id", optional: true
+
+      def fulfilled?(answer_form)
+        return answer_form.present? if condition_type == "answered"
+        return answer_form.blank? if condition_type == "not_answered"
+        # rest of options require presence
+        return if answer_form.blank?
+
+        case condition_type
+        when "equal"
+          answer_form.choices.pluck(:answer_option_id).include?(answer_option.id)
+        when "not_equal"
+          answer_form.choices.pluck(:answer_option_id).exclude?(answer_option.id)
+        when "match"
+          condition_value.values.reject(&:blank?).any? { |value| answer_form_matches?(answer_form, value) }
+        end
+      end
+
+      def to_html_data
+        {
+          id: id,
+          type: condition_type,
+          condition: decidim_condition_question_id,
+          option: decidim_answer_option_id,
+          mandatory: mandatory,
+          value: condition_value&.dig(I18n.locale.to_s)
+        }.compact
+      end
+
+      private
+
+      def answer_form_matches?(answer_form, value)
+        search = Regexp.new(value, Regexp::IGNORECASE)
+        if answer_form.body
+          answer_form.body.match?(search)
+        else
+          answer_form.choices.any? do |choice_value|
+            choice_value.body&.match?(search) || choice_value.custom_body&.match?(search)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/forms/question.rb

@@ -4,20 +4,62 @@ module Decidim
   module Forms
     # The data store for a Question in the Decidim::Forms component.
     class Question < Forms::ApplicationRecord
-      TYPES = %w(short_answer long_answer single_option multiple_option sorting).freeze
+      include Decidim::TranslatableResource
+
+      QUESTION_TYPES = %w(short_answer long_answer single_option multiple_option sorting matrix_single matrix_multiple).freeze
+      SEPARATOR_TYPE = "separator"
+      TYPES = (QUESTION_TYPES + [SEPARATOR_TYPE]).freeze
+
+      translatable_fields :body, :description
 
       belongs_to :questionnaire, class_name: "Questionnaire", foreign_key: "decidim_questionnaire_id"
 
+      has_many :matrix_rows,
+               class_name: "QuestionMatrixRow",
+               foreign_key: "decidim_question_id",
+               dependent: :destroy,
+               inverse_of: :question
+
       has_many :answer_options,
                class_name: "AnswerOption",
                foreign_key: "decidim_question_id",
                dependent: :destroy,
                inverse_of: :question
 
+      # Conditions to display this question in questionnaire
+      has_many :display_conditions,
+               class_name: "DisplayCondition",
+               foreign_key: "decidim_question_id",
+               dependent: :destroy,
+               inverse_of: :question
+
+      # Conditions to display other questions based on the value of this question's answer
+      has_many :display_conditions_for_other_questions,
+               class_name: "DisplayCondition",
+               foreign_key: "decidim_condition_question_id",
+               dependent: :destroy,
+               inverse_of: :question
+
+      # Questions which have display conditions based on the value of this question's answer
+      has_many :conditioned_questions,
+               through: :display_conditions_for_other_questions,
+               foreign_key: "decidim_condition_question_id",
+               class_name: "Question"
+
       validates :question_type, inclusion: { in: TYPES }
 
+      scope :with_body, -> { where(question_type: %w(short_answer long_answer)) }
+      scope :with_choices, -> { where.not(question_type: %w(short_answer long_answer)) }
+
+      scope :conditioned, -> { includes(:display_conditions).where.not(decidim_forms_display_conditions: { id: nil }) }
+      scope :not_conditioned, -> { includes(:display_conditions).where(decidim_forms_display_conditions: { id: nil }) }
+
+      def matrix?
+        %w(matrix_single matrix_multiple).include?(question_type)
+      end
+
       def multiple_choice?
-        %w(single_option multiple_option sorting).include?(question_type)
+        %w(single_option multiple_option sorting matrix_single matrix_multiple).include?(question_type)
       end
 
       def mandatory_body?
@@ -31,6 +73,14 @@ module Decidim
       def number_of_options
         answer_options.size
       end
+
+      def translated_body
+        Decidim::Forms::QuestionPresenter.new(self).translated_body
+      end
+
+      def separator?
+        question_type.to_s == SEPARATOR_TYPE
+      end
     end
   end
 end

data/app/models/decidim/forms/question_matrix_row.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # The data store for a QuestionMatrix in the Decidim::Forms component.
+    class QuestionMatrixRow < Forms::ApplicationRecord
+      include Decidim::TranslatableResource
+
+      translatable_fields :body
+      belongs_to :question, class_name: "Question", foreign_key: "decidim_question_id"
+
+      delegate :answer_options, :mandatory, :max_choices, to: :question
+    end
+  end
+end

data/app/models/decidim/forms/questionnaire.rb

@@ -4,6 +4,11 @@ module Decidim
   module Forms
     # The data store for a Questionnaire in the Decidim::Forms component.
     class Questionnaire < Forms::ApplicationRecord
+      include Decidim::Templates::Templatable if defined? Decidim::Templates::Templatable
+      include Decidim::Publicable
+      include Decidim::TranslatableResource
+
+      translatable_fields :title, :description, :tos
       belongs_to :questionnaire_for, polymorphic: true
 
       has_many :questions, -> { order(:position) }, class_name: "Question", foreign_key: "decidim_questionnaire_id", dependent: :destroy
@@ -11,7 +16,8 @@ module Decidim
 
       # Public: returns whether the questionnaire questions can be modified or not.
       def questions_editable?
-        answers.empty?
+        has_component = questionnaire_for.respond_to? :component
+        (has_component && !questionnaire_for.component.published?) || answers.empty?
       end
 
       # Public: returns whether the questionnaire is answered by the user or not.
@@ -19,6 +25,10 @@ module Decidim
         query = user.is_a?(String) ? { session_token: user } : { user: user }
         answers.where(query).any? if questions.present?
       end
+
+      def pristine?
+        created_at.to_i == updated_at.to_i && questions.empty?
+      end
     end
   end
 end

data/app/presenters/decidim/forms/admin/questionnaire_answer_presenter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      #
+      # Presenter for questionnaire answer
+      #
+      class QuestionnaireAnswerPresenter < Rectify::Presenter
+        include Decidim::TranslatableAttributes
+
+        attribute :answer, Decidim::Forms::Answer
+
+        def question
+          translated_attribute(answer.question.body)
+        end
+
+        def body
+          return answer.body if answer.body.present?
+          return "-" if answer.choices.empty?
+
+          choices = answer.choices.map do |choice|
+            choice.try(:custom_body) || choice.try(:body)
+          end
+
+          return choices.first if answer.question.question_type == "single_option"
+
+          content_tag(:ul) do
+            safe_join(choices.map { |c| choice(c) })
+          end
+        end
+
+        private
+
+        def choice(choice_body)
+          content_tag :li do
+            choice_body
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/forms/admin/questionnaire_participant_presenter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      #
+      # Presenter for questionnaire response
+      #
+      class QuestionnaireParticipantPresenter < Rectify::Presenter
+        attribute :participant, Decidim::Forms::Answer
+
+        def session_token
+          participant.session_token || "-"
+        end
+
+        def ip_hash
+          participant.ip_hash || "-"
+        end
+
+        def answered_at
+          participant.created_at
+        end
+
+        delegate :questionnaire, to: :participant
+
+        def registered?
+          participant.decidim_user_id.present?
+        end
+
+        def status
+          t(registered? ? "registered" : "unregistered", scope: "decidim.forms.user_answers_serializer")
+        end
+
+        def answers
+          sibilings.map { |answer| QuestionnaireAnswerPresenter.new(answer: answer) }
+        end
+
+        def first_short_answer
+          short = sibilings.where("decidim_forms_questions.question_type in (?)", %w(short_answer))
+          short.first
+        end
+
+        def completion
+          with_body = sibilings.where("decidim_forms_questions.question_type in (?)", %w(short_answer long_answer))
+                               .where.not(body: "").count
+          with_choices = sibilings.where.not("decidim_forms_questions.question_type in (?)", %w(short_answer long_answer))
+                                  .where("decidim_forms_answers.id IN (SELECT decidim_answer_id FROM decidim_forms_answer_choices)").count
+
+          (with_body + with_choices).to_f / questionnaire.questions.count * 100
+        end
+
+        private
+
+        def sibilings
+          Answer.where(session_token: participant.session_token).joins(:question).order("decidim_forms_questions.position ASC")
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/forms/answer_option_presenter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    #
+    # Decorator for answer_options
+    #
+    class AnswerOptionPresenter < SimpleDelegator
+      include Decidim::TranslationsHelper
+
+      def translated_body
+        @translated_body ||= translated_attribute body
+      end
+
+      def as_json(*_args)
+        { id: id, body: translated_body }
+      end
+    end
+  end
+end

data/app/presenters/decidim/forms/question_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    #
+    # Decorator for questions
+    #
+    class QuestionPresenter < SimpleDelegator
+      include Decidim::TranslationsHelper
+
+      def translated_body
+        @translated_body ||= translated_attribute body
+      end
+    end
+  end
+end

data/app/queries/decidim/forms/questionnaire_participant.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # A class used to collect user answers for a questionnaire
+    class QuestionnaireParticipant < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # questionnaire - a Questionnaire object
+      # session_token = the session_token used by the questionnaire participant
+      def self.for(questionnaire, session_token)
+        new(questionnaire, session_token).query
+      end
+
+      # Initializes the class.
+      #
+      # questionnaire = a Questionnaire object
+      # session_token = the session_token used by the questionnaire participant
+      def initialize(questionnaire, session_token)
+        @questionnaire = questionnaire
+        @token = session_token
+      end
+
+      # Returns query with participant info
+      def query
+        answers.select(:session_token, :decidim_user_id, :ip_hash).first
+      end
+
+      # Finds the participant's answers.
+      def answers
+        Answer.where(questionnaire: @questionnaire, session_token: @token)
+      end
+    end
+  end
+end