decidim-forms 0.22.0 → 0.23.0

data/app/assets/javascripts/decidim/forms/display_conditions.component.js.es6

@@ -0,0 +1,204 @@
+/* eslint-disable no-ternary, no-plusplus */
+
+((exports) => {
+  class DisplayCondition {
+    constructor(options = {}) {
+      this.wrapperField = options.wrapperField;
+      this.type = options.type;
+      this.conditionQuestion = options.conditionQuestion;
+      this.answerOption = options.answerOption;
+      this.mandatory = options.mandatory;
+      this.value = options.value;
+      this.onFulfilled = options.onFulfilled;
+      this.bindEvent();
+    }
+
+    bindEvent() {
+      this.checkCondition();
+      this.getInputsToListen().on("change", this.checkCondition.bind(this));
+    }
+
+    getInputValue() {
+      const $conditionWrapperField = $(`.question[data-question-id='${this.conditionQuestion}']`);
+      const $textInput = $conditionWrapperField.find("textarea, input[type='text']:not([name$=\\[custom_body\\]])");
+
+      if ($textInput.length) {
+        return $textInput.val();
+      }
+
+      let multipleInput = [];
+
+      $conditionWrapperField.find(".radio-button-collection, .check-box-collection").find(".collection-input").each((idx, el) => {
+        const $label = $(el).find("label");
+        const checked = !$label.find("input[type='hidden']").is("[disabled]");
+
+        if (checked) {
+          const $textField = $(el).find("input[name$=\\[custom_body\\]]");
+          const text = $textField.val();
+          const value = $label.find("input:not([type='hidden'])").val();
+          const id = $label.find("input[type='hidden']").val();
+
+          multipleInput.push({ id, value, text });
+        }
+      });
+
+      return multipleInput;
+    }
+
+    getInputsToListen() {
+      const $conditionWrapperField = $(`.question[data-question-id='${this.conditionQuestion}']`);
+      const $textInput = $conditionWrapperField.find("textarea, input[type='text']:not([name$=\\[custom_body\\]])");
+
+      if ($textInput.length) {
+        return $textInput;
+      }
+
+      return $conditionWrapperField.find(".collection-input").find("input:not([type='hidden'])");
+    }
+
+    checkAnsweredCondition(value) {
+      if (typeof (value) !== "object") {
+        return Boolean(value);
+      }
+
+      return Boolean(value.some((it) => it.value));
+    }
+
+    checkNotAnsweredCondition(value) {
+      return !this.checkAnsweredCondition(value);
+    }
+
+    checkEqualCondition(value) {
+      if (value.length) {
+        return value.some((it) => it.id === this.answerOption.toString());
+      }
+      return false;
+    }
+
+    checkNotEqualCondition(value) {
+      if (value.length) {
+        return value.every((it) => it.id !== this.answerOption.toString());
+      }
+      return false;
+    }
+
+    checkMatchCondition(value) {
+      let regexp = new RegExp(this.value, "i");
+
+      if (typeof (value) !== "object") {
+        return Boolean(value.match(regexp));
+      }
+
+      return value.some(function (it) {
+        return it.text
+          ? it.text.match(regexp)
+          : it.value.match(regexp)
+      });
+    }
+
+    checkCondition() {
+      const value = this.getInputValue();
+      let fulfilled = false;
+
+      switch (this.type) {
+      case "answered":
+        fulfilled = this.checkAnsweredCondition(value);
+        break;
+      case "not_answered":
+        fulfilled = this.checkNotAnsweredCondition(value);
+        break;
+      case "equal":
+        fulfilled = this.checkEqualCondition(value);
+        break;
+      case "not_equal":
+        fulfilled = this.checkNotEqualCondition(value);
+        break;
+      case "match":
+        fulfilled = this.checkMatchCondition(value);
+        break;
+      default:
+        fulfilled = false;
+        break;
+      }
+
+      this.onFulfilled(fulfilled);
+    }
+  }
+
+  class DisplayConditionsComponent {
+    constructor(options = {}) {
+      this.wrapperField = options.wrapperField;
+      this.conditions = {};
+      this.showCount = 0;
+      this.initializeConditions();
+    }
+
+    initializeConditions() {
+      const $conditionElements = this.wrapperField.find(".display-condition");
+
+      $conditionElements.each((idx, el) => {
+        const $condition = $(el);
+        const id = $condition.data("id");
+        this.conditions[id] = {};
+
+        this.conditions[id] = new DisplayCondition({
+          wrapperField: this.wrapperField,
+          type: $condition.data("type"),
+          conditionQuestion: $condition.data("condition"),
+          answerOption: $condition.data("option"),
+          mandatory: $condition.data("mandatory"),
+          value: $condition.data("value"),
+          onFulfilled: (fulfilled) => {
+            this.onFulfilled(id, fulfilled);
+          }
+        });
+      });
+    }
+
+    mustShow() {
+      const conditions = Object.values(this.conditions);
+      const mandatoryConditions = conditions.filter((condition) => condition.mandatory);
+      const nonMandatoryConditions = conditions.filter((condition) => !condition.mandatory);
+
+      if (mandatoryConditions.length) {
+        return mandatoryConditions.every((condition) => condition.fulfilled);
+      }
+
+      return nonMandatoryConditions.some((condition) => condition.fulfilled);
+
+    }
+
+    onFulfilled(id, fulfilled) {
+      this.conditions[id].fulfilled = fulfilled;
+
+      if (this.mustShow()) {
+        this.showQuestion();
+      }
+      else {
+        this.hideQuestion();
+      }
+    }
+
+    showQuestion() {
+      this.wrapperField.fadeIn();
+      this.wrapperField.find("input, textarea").prop("disabled", null);
+      this.showCount++;
+    }
+
+    hideQuestion() {
+      if (this.showCount) {
+        this.wrapperField.fadeOut();
+      }
+      else {
+        this.wrapperField.hide();
+      }
+
+      this.wrapperField.find("input, textarea").prop("disabled", "disabled");
+    }
+  }
+
+  exports.Decidim = exports.Decidim || {};
+  exports.Decidim.createDisplayConditions = (options) => {
+    return new DisplayConditionsComponent(options);
+  };
+})(window);

data/app/assets/javascripts/decidim/forms/forms.js.es6

@@ -1,9 +1,10 @@
 // = require ./option_attached_inputs.component
 // = require ./autosortable_checkboxes.component
+// = require ./display_conditions.component
 // = require ./max_choices_alert.component
 
 ((exports) => {
-  const { createOptionAttachedInputs, createAutosortableCheckboxes, createMaxChoicesAlertComponent } = exports.Decidim;
+  const { createOptionAttachedInputs, createAutosortableCheckboxes, createMaxChoicesAlertComponent, createDisplayConditions } = exports.Decidim;
 
   $(".radio-button-collection, .check-box-collection").each((idx, el) => {
     createOptionAttachedInputs({
@@ -32,6 +33,12 @@
     })
   });
 
+  $(".answer-questionnaire .question[data-conditioned='true']").each((idx, el) => {
+    createDisplayConditions({
+      wrapperField: $(el)
+    });
+  });
+
   const $form = $("form.answer-questionnaire");
   if ($form.length > 0) {
     $form.find("input, textarea, select").on("change", () => {

data/app/assets/stylesheets/decidim/forms/questionnaire-answers-pdf.scss

@@ -0,0 +1,69 @@
+.questionnaire-answers{
+  .header{
+    h1{
+      margin: 0;
+      padding: 25px;
+      background: rgb(59, 69, 87);
+      color: white;
+      border-radius: 4px 4px 0 0;
+    }
+
+    .description{
+      margin: 0;
+      padding: 25px;
+      background: #f6f6f6;
+      color: #202751;
+      border-radius: 0 0 4px 4px;
+    }
+  }
+
+  .answer{
+    margin-top: 25px;
+    background: #f6f6f6;
+    border-radius: 0 0 4px 4px;
+
+    .title{
+      page-break-inside: avoid;
+      border-radius: 4px 4px 0 0;
+      padding: 10px 25px;
+      background: rgb(59, 69, 87);
+      color: white;
+    }
+
+    .participant-info{
+      margin-top: 0;
+      padding: 10px 25px;
+      width: 100%;
+      text-align: center;
+      background: #eee;
+      color: #202751;
+      page-break-inside: avoid;
+
+      th:first-child{
+        text-align: left;
+      }
+
+      td:first-child{
+        text-align: left;
+      }
+
+      th:last-child{
+        text-align: right;
+      }
+
+      td:last-child{
+        text-align: right;
+      }
+    }
+
+    .answers{
+      padding: 25px;
+
+      .question{
+        page-break-inside: avoid;
+        font-size: inherit;
+        color: #202751;
+      }
+    }
+  }
+}

data/app/commands/decidim/forms/admin/update_questionnaire.rb

@@ -22,7 +22,11 @@ module Decidim
           return broadcast(:invalid) if @form.invalid?
 
           Decidim::Forms::Questionnaire.transaction do
-            update_questionnaire_questions if @questionnaire.questions_editable?
+            if @questionnaire.questions_editable?
+              update_questionnaire_questions
+              delete_answers unless @questionnaire.published?
+            end
+
             update_questionnaire
           end
 
@@ -57,6 +61,22 @@ module Decidim
               update_nested_model(form_answer_option, answer_option_attributes, question.answer_options)
             end
 
+            form_question.display_conditions.each do |form_display_condition|
+              type = form_display_condition.condition_type
+
+              display_condition_attributes = {
+                condition_question: form_display_condition.condition_question,
+                condition_type: form_display_condition.condition_type,
+                condition_value: type == "match" ? form_display_condition.condition_value : nil,
+                answer_option: %w(equal not_equal).include?(type) ? form_display_condition.answer_option : nil,
+                mandatory: form_display_condition.mandatory
+              }
+
+              next if form_display_condition.deleted? && form_display_condition.id.blank?
+
+              update_nested_model(form_display_condition, display_condition_attributes, question.display_conditions)
+            end
+
             form_question.matrix_rows.each do |form_matrix_row|
               matrix_row_attributes = {
                 body: form_matrix_row.body
@@ -88,6 +108,10 @@ module Decidim
                                  description: @form.description,
                                  tos: @form.tos)
         end
+
+        def delete_answers
+          @questionnaire.answers.destroy_all
+        end
       end
     end
   end

data/app/commands/decidim/forms/answer_questionnaire.rb

@@ -30,7 +30,7 @@ module Decidim
 
       def answer_questionnaire
         Answer.transaction do
-          form.responses_by_step.flatten.each do |form_answer|
+          form.responses_by_step.flatten.select(&:display_conditions_fulfilled?).each do |form_answer|
             answer = Answer.new(
               user: @current_user,
               questionnaire: @questionnaire,

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

@@ -15,7 +15,21 @@ module Decidim
 
           included do
             helper Decidim::Forms::Admin::ApplicationHelper
-            helper_method :questionnaire_for, :questionnaire, :blank_question, :blank_answer_option, :blank_matrix_row, :question_types, :update_url
+            helper_method :questionnaire_for, :questionnaire, :blank_question, :blank_answer_option, :blank_matrix_row,
+                          :blank_display_condition, :question_types, :display_condition_types, :update_url, :public_url, :answer_options_url
+
+            if defined? Decidim::Templates::Admin
+              include Decidim::Templates::Admin::Concerns::Templatable
+              helper Decidim::Templates::Admin::TemplatesHelper
+
+              def templatable_type
+                "Decidim::Forms::Questionnaire"
+              end
+
+              def templatable
+                questionnaire
+              end
+            end
 
             def edit
               enforce_permission_to :update, :questionnaire, questionnaire: questionnaire
@@ -46,6 +60,16 @@ module Decidim
               end
             end
 
+            def answer_options
+              respond_to do |format|
+                format.json do
+                  question_id = params["id"]
+                  question = Question.find_by(id: question_id)
+                  render json: question.answer_options.map { |answer_option| AnswerOptionPresenter.new(answer_option).as_json } if question.present?
+                end
+              end
+            end
+
             # Public: The only method to be implemented at the controller. You need to
             # return the object that will hold the questionnaire.
             def questionnaire_for
@@ -64,6 +88,18 @@ module Decidim
               url_for(questionnaire.questionnaire_for)
             end
 
+            # Implement this method in your controller to set the URL
+            # where the questionnaire can be answered.
+            def public_url
+              raise "#{self.class.name} is expected to implement #public_url"
+            end
+
+            # Returns the url to get the answer options json (for the display conditions form)
+            # for the question with id = params[:id]
+            def answer_options_url(params)
+              url_for([questionnaire.questionnaire_for, action: :answer_options, format: :json, **params])
+            end
+
             private
 
             def i18n_flashes_scope
@@ -82,6 +118,10 @@ module Decidim
               @blank_answer_option ||= Admin::AnswerOptionForm.new
             end
 
+            def blank_display_condition
+              @blank_display_condition ||= Admin::DisplayConditionForm.new
+            end
+
             def blank_matrix_row
               @blank_matrix_row ||= Admin::QuestionMatrixRowForm.new
             end
@@ -91,6 +131,12 @@ module Decidim
                 [question_type, I18n.t("decidim.forms.question_types.#{question_type}")]
               end
             end
+
+            def display_condition_types
+              @display_condition_types ||= DisplayCondition.condition_types.keys.map do |condition_type|
+                [condition_type, I18n.t("decidim.forms.admin.questionnaires.display_condition.condition_types.#{condition_type}")]
+              end
+            end
           end
         end
       end

data/app/controllers/decidim/forms/admin/concerns/has_questionnaire_answers.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      module Concerns
+        # Questionnaires can be related to any class in Decidim. In order to
+        # manage the questionnaires answers for a given type, you should create a new
+        # controller and include the HasQuestionnaire concern as well as this one.
+        #
+        # In the controller that includes this concern, you should define a
+        # `questionnaire_for` method that returns an instance of the model that the
+        # questionnaire belongs to. You should also define the routes for:
+        # `index_<model>_url` and `export_<model>_url` as well as
+        # `show_<model>_url` and `export_response_<model>_url` (which are passed
+        # a `:session_token` parameter)
+        module HasQuestionnaireAnswers
+          extend ActiveSupport::Concern
+
+          included do
+            include Decidim::Paginable
+            include Decidim::Forms::Admin::Concerns::HasQuestionnaireAnswersUrlHelper
+            include Decidim::Forms::Admin::Concerns::HasQuestionnaireAnswersPaginationHelper
+
+            helper Decidim::Forms::Admin::QuestionnaireAnswersHelper
+
+            def index
+              enforce_permission_to :index, :questionnaire_answers
+
+              @query = paginate(collection)
+              @participants = participants(@query)
+              @total = participants_query.count_participants
+
+              render template: "decidim/forms/admin/questionnaires/answers/index"
+            end
+
+            def show
+              enforce_permission_to :show, :questionnaire_answers
+
+              @participant = participant(participants_query.participant(params[:session_token]))
+
+              render template: "decidim/forms/admin/questionnaires/answers/show"
+            end
+
+            def export_response
+              enforce_permission_to :export_response, :questionnaire_answers
+
+              session_token = params[:session_token]
+              answers = QuestionnaireUserAnswers.for(questionnaire)
+
+              # i18n-tasks-use t("decidim.forms.admin.questionnaires.answers.export_response.title")
+              title = t("export_response.title", scope: i18n_scope, token: session_token)
+
+              Decidim::Forms::ExportQuestionnaireAnswersJob.perform_later(current_user, title, answers.select { |a| a.first.session_token == session_token })
+
+              flash[:notice] = t("decidim.admin.exports.notice")
+
+              redirect_back(fallback_location: questionnaire_participant_answers_url(session_token))
+            end
+
+            # Public: The only method to be implemented at the controller. You need to
+            # return the object that will hold the questionnaire.
+            def questionnaire_for
+              raise "#{self.class.name} is expected to implement #questionnaire_for"
+            end
+
+            private
+
+            def i18n_scope
+              "decidim.forms.admin.questionnaires.answers"
+            end
+
+            def questionnaire
+              @questionnaire ||= Questionnaire.find_by(questionnaire_for: questionnaire_for)
+            end
+
+            def participants_query
+              QuestionnaireParticipants.new(questionnaire)
+            end
+
+            def collection
+              @collection ||= participants_query.participants
+            end
+
+            def participant(answer)
+              Decidim::Forms::Admin::QuestionnaireParticipantPresenter.new(participant: answer)
+            end
+
+            def participants(query)
+              query.map { |answer| participant(answer) }
+            end
+          end
+        end
+      end
+    end
+  end
+end