decidim-forms 0.16.0

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # This command is executed when the user changes a Questionnaire from the admin
+      # panel.
+      class UpdateQuestionnaire < Rectify::Command
+        # Initializes a UpdateQuestionnaire Command.
+        #
+        # form - The form from which to get the data.
+        # questionnaire - The current instance of the questionnaire to be updated.
+        def initialize(form, questionnaire)
+          @form = form
+          @questionnaire = questionnaire
+        end
+
+        # Updates the questionnaire if valid.
+        #
+        # Broadcasts :ok if successful, :invalid otherwise.
+        def call
+          return broadcast(:invalid) if @form.invalid?
+
+          Decidim::Forms::Questionnaire.transaction do
+            update_questionnaire_questions if @questionnaire.questions_editable?
+            update_questionnaire
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        def update_questionnaire_questions
+          @form.questions.each do |form_question|
+            update_questionnaire_question(form_question)
+          end
+        end
+
+        def update_questionnaire_question(form_question)
+          question_attributes = {
+            body: form_question.body,
+            description: form_question.description,
+            position: form_question.position,
+            mandatory: form_question.mandatory,
+            question_type: form_question.question_type,
+            max_choices: form_question.max_choices
+          }
+
+          update_nested_model(form_question, question_attributes, @questionnaire.questions) do |question|
+            form_question.answer_options.each do |form_answer_option|
+              answer_option_attributes = {
+                body: form_answer_option.body,
+                free_text: form_answer_option.free_text
+              }
+
+              update_nested_model(form_answer_option, answer_option_attributes, question.answer_options)
+            end
+          end
+        end
+
+        def update_nested_model(form, attributes, parent_association)
+          record = parent_association.find_by(id: form.id) || parent_association.build(attributes)
+
+          yield record if block_given?
+
+          if record.persisted?
+            if form.deleted?
+              record.destroy!
+            else
+              record.update!(attributes)
+            end
+          else
+            record.save!
+          end
+        end
+
+        def update_questionnaire
+          @questionnaire.update!(title: @form.title,
+                                 description: @form.description,
+                                 tos: @form.tos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # This command is executed when the user answers a Questionnaire.
+    class AnswerQuestionnaire < Rectify::Command
+      # Initializes a AnswerQuestionnaire Command.
+      #
+      # form - The form from which to get the data.
+      # questionnaire - The current instance of the questionnaire to be answered.
+      def initialize(form, current_user, questionnaire)
+        @form = form
+        @current_user = current_user
+        @questionnaire = questionnaire
+      end
+
+      # Answers a questionnaire if it is valid
+      #
+      # Broadcasts :ok if successful, :invalid otherwise.
+      def call
+        return broadcast(:invalid) if @form.invalid?
+
+        answer_questionnaire
+        broadcast(:ok)
+      end
+
+      private
+
+      def answer_questionnaire
+        Answer.transaction do
+          @form.answers.each do |form_answer|
+            answer = Answer.new(
+              user: @current_user,
+              questionnaire: @questionnaire,
+              question: form_answer.question,
+              body: form_answer.body
+            )
+
+            form_answer.selected_choices.each do |choice|
+              answer.choices.build(
+                body: choice.body,
+                custom_body: choice.custom_body,
+                decidim_answer_option_id: choice.answer_option_id,
+                position: choice.position
+              )
+            end
+
+            answer.save!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# 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 for a given type, you should create a new
+        # controller and include this concern.
+        #
+        # The only requirement is to define a `questionnaire_for` method that
+        # returns an instance of the model that questionnaire belongs to.
+        module HasQuestionnaire
+          extend ActiveSupport::Concern
+
+          included do
+            helper Decidim::Forms::Admin::ApplicationHelper
+            helper_method :questionnaire_for, :questionnaire, :blank_question, :blank_answer_option, :question_types, :update_url
+
+            def edit
+              enforce_permission_to :update, :questionnaire, questionnaire: questionnaire
+
+              @form = form(Admin::QuestionnaireForm).from_model(questionnaire)
+
+              render template: "decidim/forms/admin/questionnaires/edit"
+            end
+
+            def update
+              enforce_permission_to :update, :questionnaire, questionnaire: questionnaire
+
+              params["published_at"] = Time.current if params.has_key? "save_and_publish"
+              @form = form(Admin::QuestionnaireForm).from_params(params)
+
+              Admin::UpdateQuestionnaire.call(@form, questionnaire) do
+                on(:ok) do
+                  # i18n-tasks-use t("decidim.forms.admin.questionnaires.update.success")
+                  flash[:notice] = I18n.t("update.success", scope: i18n_flashes_scope)
+                  redirect_to after_update_url
+                end
+
+                on(:invalid) do
+                  # i18n-tasks-use t("decidim.forms.admin.questionnaires.update.invalid")
+                  flash.now[:alert] = I18n.t("update.invalid", scope: i18n_flashes_scope)
+                  render template: "decidim/forms/admin/questionnaires/edit"
+                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
+              raise "#{self.class.name} is expected to implement #questionnaire_for"
+            end
+
+            # You can implement this method in your controller to change the URL
+            # where the questionnaire will be submitted.
+            def update_url
+              url_for(questionnaire.questionnaire_for)
+            end
+
+            # You can implement this method in your controller to change the URL
+            # where the user will be redirected after updating the questionnaire
+            def after_update_url
+              url_for(questionnaire.questionnaire_for)
+            end
+
+            private
+
+            def i18n_flashes_scope
+              "decidim.forms.admin.questionnaires"
+            end
+
+            def questionnaire
+              @questionnaire ||= Questionnaire.find_by(questionnaire_for: questionnaire_for)
+            end
+
+            def blank_question
+              @blank_question ||= Admin::QuestionForm.new
+            end
+
+            def blank_answer_option
+              @blank_answer_option ||= Admin::AnswerOptionForm.new
+            end
+
+            def question_types
+              @question_types ||= Question::TYPES.map do |question_type|
+                [question_type, I18n.t("decidim.forms.question_types.#{question_type}")]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Concerns
+      # Questionnaires can be related to any class in Decidim, in order to
+      # manage the questionnaires for a given type, you should create a new
+      # controller and include this concern.
+      #
+      # The only requirement is to define a `questionnaire_for` method that
+      # returns an instance of the model that questionnaire belongs to.
+      module HasQuestionnaire
+        extend ActiveSupport::Concern
+
+        included do
+          include FormFactory
+
+          helper_method :questionnaire_for, :questionnaire, :allow_answers?, :update_url
+
+          def show
+            @form = form(Decidim::Forms::QuestionnaireForm).from_model(questionnaire)
+            render template: "decidim/forms/questionnaires/show"
+          end
+
+          def answer
+            enforce_permission_to :answer, :questionnaire
+
+            @form = form(Decidim::Forms::QuestionnaireForm).from_params(params)
+
+            Decidim::Forms::AnswerQuestionnaire.call(@form, current_user, questionnaire) do
+              on(:ok) do
+                # i18n-tasks-use t("decidim.forms.questionnaires.answer.success")
+                flash[:notice] = I18n.t("answer.success", scope: i18n_flashes_scope)
+                redirect_to after_answer_path
+              end
+
+              on(:invalid) do
+                # i18n-tasks-use t("decidim.forms.questionnaires.answer.invalid")
+                flash.now[:alert] = I18n.t("answer.invalid", scope: i18n_flashes_scope)
+                render template: "decidim/forms/questionnaires/show"
+              end
+            end
+          end
+
+          # Public: Method to be implemented at the controller. You need to
+          # return true if the questionnaire can receive answers
+          def allow_answers?
+            raise "#{self.class.name} is expected to implement #allow_answers?"
+          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.
+          #
+          # It can be redefined at controller level if you need to redirect elsewhere.
+          def after_answer_path
+            questionnaire_for
+          end
+
+          # You can implement this method in your controller to change the URL
+          # where the questionnaire will be submitted.
+          def update_url
+            url_for([questionnaire_for, action: :answer])
+          end
+
+          # Public: 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_flashes_scope
+            "decidim.forms.questionnaires"
+          end
+
+          def questionnaire
+            @questionnaire ||= Questionnaire.includes(questions: :answer_options).find_by(questionnaire_for: questionnaire_for)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # This class holds a Form to update answer options
+      class AnswerOptionForm < Decidim::Form
+        include TranslatableAttributes
+
+        attribute :deleted, Boolean, default: false
+        attribute :free_text, Boolean
+
+        translatable_attribute :body, String
+
+        validates :body, translatable_presence: true, unless: :deleted
+
+        def to_param
+          id || "questionnaire-question-answer-option-id"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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 QuestionForm < Decidim::Form
+        include TranslatableAttributes
+
+        attribute :position, Integer
+        attribute :mandatory, Boolean, default: false
+        attribute :question_type, String
+        attribute :answer_options, Array[AnswerOptionForm]
+        attribute :max_choices, Integer
+        attribute :deleted, Boolean, default: false
+
+        translatable_attribute :body, String
+        translatable_attribute :description, String
+
+        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
+
+        def to_param
+          id || "questionnaire-question-id"
+        end
+
+        def number_of_options
+          answer_options.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    module Admin
+      # This class holds a Form to update questionnaires from Decidim's admin panel.
+      class QuestionnaireForm < Decidim::Form
+        include TranslatableAttributes
+
+        translatable_attribute :title, String
+        translatable_attribute :description, String
+        translatable_attribute :tos, String
+
+        attribute :published_at, Decidim::Attributes::TimeWithZone
+        attribute :questions, Array[QuestionForm]
+
+        validates :title, :tos, translatable_presence: true
+
+        def map_model(model)
+          self.questions = model.questions.map do |question|
+            QuestionForm.from_model(question)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # This class holds a Form to save the chosen option for an answer
+    class AnswerChoiceForm < Decidim::Form
+      attribute :body, String
+      attribute :custom_body, String
+      attribute :position, Integer
+      attribute :answer_option_id, Integer
+
+      validates :answer_option_id, presence: true
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # This class holds a Form to save the questionnaire answers from Decidim's public page
+    class AnswerForm < Decidim::Form
+      include Decidim::TranslationsHelper
+
+      attribute :question_id, String
+      attribute :body, String
+      attribute :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" }
+
+      delegate :mandatory_body?, :mandatory_choices?, to: :question
+
+      attr_writer :question
+
+      def question
+        @question ||= Decidim::Forms::Question.find(question_id)
+      end
+
+      def label(idx)
+        base = "#{idx + 1}. #{translated_attribute(question.body)}"
+        base += " #{mandatory_label}" if question.mandatory?
+        base += " (#{max_choices_label})" if question.max_choices
+        base
+      end
+
+      # Public: Map the correct fields.
+      #
+      # Returns nothing.
+      def map_model(model)
+        self.question_id = model.decidim_question_id
+        self.question = model.question
+
+        self.choices = model.choices.map do |choice|
+          AnswerChoiceForm.from_model(choice)
+        end
+      end
+
+      def selected_choices
+        choices.select(&:body)
+      end
+
+      private
+
+      def max_choices
+        errors.add(:choices, :too_many) if selected_choices.size > question.max_choices
+      end
+
+      def all_choices
+        errors.add(:choices, :missing) if selected_choices.size != question.number_of_options
+      end
+
+      def mandatory_label
+        "*"
+      end
+
+      def max_choices_label
+        I18n.t("questionnaires.question.max_choices", scope: "decidim.forms", n: question.max_choices)
+      end
+    end
+  end
+end