decidim-forms 0.19.1 → 0.23.0

data/app/controllers/decidim/forms/concerns/has_questionnaire.rb

@@ -16,7 +16,9 @@ module Decidim
           helper Decidim::Forms::ApplicationHelper
           include FormFactory
 
-          helper_method :questionnaire_for, :questionnaire, :allow_answers?, :update_url
+          helper_method :questionnaire_for, :questionnaire, :allow_answers?, :visitor_can_answer?, :visitor_already_answered?, :update_url, :form_path
+
+          invisible_captcha on_spam: :spam_detected
 
           def show
             @form = form(Decidim::Forms::QuestionnaireForm).from_model(questionnaire)
@@ -26,7 +28,7 @@ module Decidim
           def answer
             enforce_permission_to :answer, :questionnaire
 
-            @form = form(Decidim::Forms::QuestionnaireForm).from_params(params)
+            @form = form(Decidim::Forms::QuestionnaireForm).from_params(params, session_token: session_token, ip_hash: ip_hash)
 
             Decidim::Forms::AnswerQuestionnaire.call(@form, current_user, questionnaire) do
               on(:ok) do
@@ -49,6 +51,22 @@ module Decidim
             raise "#{self.class.name} is expected to implement #allow_answers?"
           end
 
+          # Public: Method to be implemented at the controller if needed. You need to
+          # return true if the questionnaire can receive answers by unregistered users
+          def allow_unregistered?
+            false
+          end
+
+          # Public: return true if the current user (if logged) can answer the questionnaire
+          def visitor_can_answer?
+            current_user || allow_unregistered?
+          end
+
+          # Public: return true if the current user (or session visitor) can answer the questionnaire
+          def visitor_already_answered?
+            questionnaire.answered_by?(current_user || tokenize(session[:session_id]))
+          end
+
           # Public: Returns a String or Object that will be passed to `redirect_to` after
           # answering the questionnaire. By default it redirects to the questionnaire_for.
           #
@@ -63,6 +81,15 @@ module Decidim
             url_for([questionnaire_for, action: :answer])
           end
 
+          # Points to the shortest path accessing the current form. This will be
+          # used to detect whether a user is leaving the form with some partial
+          # answers, so that we can warn them.
+          #
+          # Overwrite this method at the controller.
+          def form_path
+            url_for([questionnaire_for, only_path: true])
+          end
+
           # Public: Method to be implemented at the controller. You need to
           # return the object that will hold the questionnaire.
           def questionnaire_for
@@ -78,6 +105,35 @@ module Decidim
           def questionnaire
             @questionnaire ||= Questionnaire.includes(questions: :answer_options).find_by(questionnaire_for: questionnaire_for)
           end
+
+          def spam_detected
+            enforce_permission_to :answer, :questionnaire
+
+            @form = form(Decidim::Forms::QuestionnaireForm).from_params(params)
+
+            flash.now[:alert] = I18n.t("answer.spam_detected", scope: i18n_flashes_scope)
+            render template: "decidim/forms/questionnaires/show"
+          end
+
+          def ip_hash
+            return nil unless request&.remote_ip
+
+            @ip_hash ||= tokenize(request&.remote_ip)
+          end
+
+          # token is used as a substitute of user_id if unregistered
+          def session_token
+            id = current_user&.id
+            session_id = request.session[:session_id] if request&.session
+
+            return nil unless id || session_id
+
+            @session_token ||= tokenize(id || session_id)
+          end
+
+          def tokenize(id)
+            Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
+          end
         end
       end
     end

data/app/forms/decidim/forms/admin/display_condition_form.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # This class holds a Form to update questionnaire questions from Decidim's admin panel.
+      class DisplayConditionForm < Decidim::Form
+        include TranslatableAttributes
+
+        attribute :decidim_question_id, Integer
+        attribute :decidim_condition_question_id, Integer
+        attribute :decidim_answer_option_id, Integer
+        attribute :condition_type, String
+        attribute :mandatory, Boolean, default: false
+        attribute :deleted, Boolean, default: false
+
+        translatable_attribute :condition_value, String
+
+        validates :question, presence: true, unless: :deleted
+        validates :condition_question, presence: true, unless: :deleted
+        validates :answer_option, presence: true, if: :answer_option_mandatory?
+
+        validates :condition_value, translatable_presence: true, if: :condition_value_mandatory?
+        validates :condition_type, presence: true, unless: :deleted
+
+        validate :condition_question_position, unless: :deleted
+        validate :valid_answer_option?, unless: :deleted
+
+        def to_param
+          return id if id.present?
+
+          "questionnaire-display-condition-id"
+        end
+
+        def answer_options
+          return [] if condition_question.blank?
+
+          condition_question.answer_options
+        end
+
+        def questions_for_select(questionnaire, id)
+          questionnaire.questions.map do |question|
+            [
+              question.translated_body,
+              question.id,
+              {
+                "disabled" => (question.question_type == "sorting" || question.id == id),
+                "data-type" => question.question_type
+              }
+            ]
+          end
+        end
+
+        # Finds the Question from the given decidim_question_id
+        #
+        # Returns a Decidim::Forms::Question
+        def question
+          @question ||= Question.find_by(id: @decidim_question_id)
+        end
+
+        # Finds the Condition Question from the given decidim_condition_question_id
+        #
+        # Returns a Decidim::Forms::Question
+        def condition_question
+          @condition_question ||= Question.find_by(id: @decidim_condition_question_id)
+        end
+
+        # Finds the Answer Option from the given decidim_answer_option_id
+        #
+        # Returns a Decidim::Forms::AnswerOption
+        def answer_option
+          @answer_option ||= AnswerOption.find_by(id: @decidim_answer_option_id)
+        end
+
+        private
+
+        def condition_value_mandatory?
+          !deleted && condition_type == "match"
+        end
+
+        def answer_option_mandatory?
+          !deleted && %w(equal not_equal).include?(condition_type)
+        end
+
+        def valid_answer_option?
+          return unless answer_option_mandatory?
+          return if answer_option.blank?
+
+          errors.add(:decidim_answer_option_id, :invalid) if answer_option.question.id != decidim_condition_question_id
+        end
+
+        def condition_question_position
+          return if decidim_question_id.blank?
+
+          errors.add(:decidim_question_id, :invalid) unless question.position&.positive?
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/forms/admin/question_form.rb

@@ -11,6 +11,8 @@ module Decidim
         attribute :mandatory, Boolean, default: false
         attribute :question_type, String
         attribute :answer_options, Array[AnswerOptionForm]
+        attribute :display_conditions, Array[DisplayConditionForm]
+        attribute :matrix_rows, Array[QuestionMatrixRowForm]
         attribute :max_choices, Integer
         attribute :deleted, Boolean, default: false
 
@@ -20,7 +22,9 @@ module Decidim
         validates :position, numericality: { greater_than_or_equal_to: 0 }
         validates :question_type, inclusion: { in: Decidim::Forms::Question::TYPES }
         validates :max_choices, numericality: { only_integer: true, greater_than: 1, less_than_or_equal_to: ->(form) { form.number_of_options } }, allow_blank: true
-        validates :body, translatable_presence: true, unless: :deleted
+        validates :body, translatable_presence: true, if: :requires_body?
+        validates :matrix_rows, presence: true, if: :matrix?
+        validates :answer_options, presence: true, if: :matrix?
 
         def to_param
           return id if id.present?
@@ -31,6 +35,22 @@ module Decidim
         def number_of_options
           answer_options.size
         end
+
+        def separator?
+          question_type == Decidim::Forms::Question::SEPARATOR_TYPE
+        end
+
+        private
+
+        def matrix?
+          question_type == "matrix_single" || question_type == "matrix_multiple"
+        end
+
+        def requires_body?
+          return false if separator?
+
+          !deleted
+        end
       end
     end
   end

data/app/forms/decidim/forms/admin/question_matrix_row_form.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # This class holds a Form to update questionnaire question matrixes from Decidim's admin panel.
+      class QuestionMatrixRowForm < Decidim::Form
+        include TranslatableAttributes
+
+        attribute :position, Integer, default: 0
+        attribute :deleted, Boolean, default: false
+
+        translatable_attribute :body, String
+
+        validates :position, numericality: { greater_than_or_equal_to: 0 }
+        validates :body, translatable_presence: true, unless: :deleted
+
+        def to_param
+          return id if id.present?
+
+          "questionnaire-question-matrix-row-id"
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/forms/answer_choice_form.rb

@@ -8,6 +8,7 @@ module Decidim
       attribute :custom_body, String
       attribute :position, Integer
       attribute :answer_option_id, Integer
+      attribute :matrix_row_id, Integer
 
       validates :answer_option_id, presence: true
     end

data/app/forms/decidim/forms/answer_form.rb

@@ -9,14 +9,16 @@ module Decidim
       attribute :question_id, String
       attribute :body, String
       attribute :choices, Array[AnswerChoiceForm]
+      attribute :matrix_choices, Array[AnswerChoiceForm]
 
       validates :body, presence: true, if: :mandatory_body?
       validates :selected_choices, presence: true, if: :mandatory_choices?
 
       validate :max_choices, if: -> { question.max_choices }
       validate :all_choices, if: -> { question.question_type == "sorting" }
+      validate :min_choices, if: -> { question.matrix? && question.mandatory? }
 
-      delegate :mandatory_body?, :mandatory_choices?, to: :question
+      delegate :mandatory_body?, :mandatory_choices?, :matrix?, to: :question
 
       attr_writer :question
 
@@ -47,10 +49,37 @@ module Decidim
         choices.select(&:body)
       end
 
+      def display_conditions_fulfilled?
+        question.display_conditions.all? do |condition|
+          answer = question.questionnaire.answers.find_by(question: condition.condition_question)
+          condition.fulfilled?(answer)
+        end
+      end
+
       private
 
+      def mandatory_body?
+        question.mandatory_body? if display_conditions_fulfilled?
+      end
+
+      def mandatory_choices?
+        question.mandatory_choices? if display_conditions_fulfilled?
+      end
+
+      def grouped_choices
+        selected_choices.group_by(&:matrix_row_id).values
+      end
+
       def max_choices
-        errors.add(:choices, :too_many) if selected_choices.size > question.max_choices
+        if matrix?
+          errors.add(:choices, :too_many) if grouped_choices.any? { |choices| choices.count > question.max_choices }
+        elsif selected_choices.size > question.max_choices
+          errors.add(:choices, :too_many)
+        end
+      end
+
+      def min_choices
+        errors.add(:choices, :missing) if grouped_choices.count != question.matrix_rows.count
       end
 
       def all_choices

data/app/forms/decidim/forms/questionnaire_form.rb

@@ -4,20 +4,50 @@ module Decidim
   module Forms
     # This class holds a Form to answer a questionnaire from Decidim's public page.
     class QuestionnaireForm < Decidim::Form
-      attribute :answers, Array[AnswerForm]
+      # as questionnaire uses "answers" for the database relationships is
+      # important not to use the same word here to avoid querying all the entries, resulting in a high performance penalty
+      attribute :responses, Array[AnswerForm]
       attribute :user_group_id, Integer
 
       attribute :tos_agreement, Boolean
+
       validates :tos_agreement, allow_nil: false, acceptance: true
+      validate :session_token_in_context
 
-      # Private: Create the answers from the questionnaire questions
+      # Private: Create the responses from the questionnaire questions
       #
       # Returns nothing.
       def map_model(model)
-        self.answers = model.questions.map do |question|
+        self.responses = model.questions.map do |question|
           AnswerForm.from_model(Decidim::Forms::Answer.new(question: question))
         end
       end
+
+      # Public: Splits reponses by step, keeping the separator.
+      #
+      # Returns an array of steps. Each step is a list of the questions in that
+      # step, including the separator.
+      def responses_by_step
+        @responses_by_step ||=
+          begin
+            steps = responses.chunk_while do |a, b|
+              !a.question.separator? || b.question.separator?
+            end.to_a
+
+            steps = [[]] if steps == []
+            steps
+          end
+      end
+
+      def total_steps
+        responses_by_step.count
+      end
+
+      def session_token_in_context
+        return if context&.session_token
+
+        errors.add(:tos_agreement, I18n.t("activemodel.errors.models.questionnaire.request_invalid"))
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# i18n-tasks-use t('decidim.templates.admin.questionnaire_templates.form.title')
+
 module Decidim
   module Forms
     module Admin
@@ -13,6 +15,41 @@ module Decidim
         def tabs_id_for_question_answer_option(question, answer_option)
           "questionnaire_question_#{question.to_param}_answer_option_#{answer_option.to_param}"
         end
+
+        def tabs_id_for_question_display_condition(question, display_condition)
+          "questionnaire_question_#{question.to_param}_display_condition_#{display_condition.to_param}"
+        end
+
+        def tabs_id_for_question_matrix_row(question, matrix_row)
+          "questionnaire_question_#{question.to_param}_matrix_row_#{matrix_row.to_param}"
+        end
+
+        def dynamic_title(title, **options)
+          data = {
+            "max-length" => options[:max_length],
+            "omission" => options[:omission],
+            "placeholder" => options[:placeholder],
+            "locale" => I18n.locale
+          }
+          content_tag :span, class: options[:class], data: data do
+            truncate translated_attribute(title), length: options[:max_length], omission: options[:omission]
+          end
+        end
+
+        def template?(questionnaire_for)
+          return unless defined? Decidim::Templates::Template
+
+          questionnaire_for.is_a? Decidim::Templates::Template
+        end
+
+        def templates_defined?
+          defined? Decidim::Templates::Admin::Concerns::Templatable
+        end
+
+        def title_for_questionnaire
+          scope = templates_defined? ? "decidim.templates.admin.questionnaire_templates" : "decidim.forms.admin.questionnaires"
+          t("form.title", scope: scope)
+        end
       end
     end
   end

data/app/helpers/decidim/forms/admin/concerns/has_questionnaire_answers_pagination_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      module Concerns
+        # Pagination helper for HasQuestionnaireAnswers controller concern
+        #
+        module HasQuestionnaireAnswersPaginationHelper
+          def self.included(base)
+            base.helper_method :prev_url, :next_url, :first?, :last?, :current_idx
+          end
+
+          def prev_url
+            return if first?
+
+            token = participant_ids[current_idx - 1]
+            questionnaire_participant_answers_url(token)
+          end
+
+          def next_url
+            return if last?
+
+            token = participant_ids[current_idx + 1]
+            questionnaire_participant_answers_url(token)
+          end
+
+          def first?
+            current_idx.zero?
+          end
+
+          def last?
+            current_idx == participant_ids.count - 1
+          end
+
+          private
+
+          def participant_ids
+            @participant_ids ||= collection.pluck(:session_token)
+          end
+
+          def current_idx
+            participant_ids.index(params[:session_token])
+          end
+        end
+      end
+    end
+  end
+end