decidim-only_forms 0.1.0

data/README.md

@@ -0,0 +1,108 @@
+<h1 align="center"><img src="https://github.com/octree-gva/meta/blob/main/decidim/static/header.png?raw=true" alt="Decidim - Octree Participatory democracy on a robust and open source solution" /></h1>
+<h4 align="center">
+    <a href="https://www.octree.ch">Octree</a> |
+    <a href="https://octree.ch/en/contact-us/">Contact Us</a> |
+    <a href="https://blog.octree.ch">Our Blog (FR)</a><br/><br/>
+    <a href="https://decidim.org">Decidim</a> |
+    <a href="https://docs.decidim.org/en/">Decidim Docs</a> |
+    <a href="https://meta.decidim.org">Participatory Governance (meta decidim)</a><br/><br/>
+    <a href="https://matrix.to/#/+decidim:matrix.org">Decidim Community (Matrix+Element.io)</a>
+</h4>
+<p align="center">
+<a href="https://mkutano.community"><img src="https://github.com/octree-gva/decidim-module-referral/blob/main/mkutano-logo.png?raw=true" alt="MKUTANO is a participatory platform where black canadians can effectively & democratically organize at scale" /></a> 
+</p>
+
+# Decidim::OnlyForms
+
+Component to create forms in a participatory space, sponsored by the [Mkutano Community](mkutano.community).
+
+## Usage
+
+OnlyForms will be available as a Component for a Participatory Space.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "decidim-only_forms"
+```
+
+And then execute:
+
+```bash
+bundle
+bundle exec rails decidim_only_forms:install:migrations
+bundle exec rails db:migrate
+```
+
+## Testing
+```
+    bundle exec rake test_app
+```
+
+## Local development
+For decidim version 0.27, use Gemfile.0.27. For version 0.26, use Gemfile.0.26
+```
+cp Gemfile.0.27 Gemfile
+``` 
+
+First, you need to run an empty database with a decidim dev container which runs nothing.
+```
+docker-compose down -v --remove-orphans
+docker-compose up -d
+```
+
+Once created, you access the decidim container
+```
+# Get the id of the decidim dev container
+docker ps --format {{.ID}} --filter=label=org.label-schema.name=decidim
+# 841ae977c7da
+docker exec -it 841ae977c7da bash
+```
+You are now in bash, run manually. This will check your environment and do migrations if needed
+```
+docker-entrypoint
+```
+
+You are now ready to use your container in the way you want for development:
+
+* Run a rails seed: `bundle exec rails db:seed`
+* Have live-reload on your assets: `bin/webpack-dev-server`
+* Execute tasks, like `bundle exec rails g migration AddSomeColumn`
+* Run the rails server: `bundle exec rails s -b 0.0.0.0`
+* etc.
+
+To stop everything, uses:
+- `docker-compose down` to stop the containers
+- `docker-compose down -v` to stop the containers and remove all previously saved data.
+
+### Debugging
+To debug something on the container:
+1. Ensure `decidim-app` is running
+```bash
+docker ps --all
+# CONTAINER ID   IMAGE                                   COMMAND                  CREATED       STATUS                 PORTS                                                                                  NAMES
+# 915e9fc474f2   decidim-module-only_forms-decidim-app   "sleep infinity"         7 hours ago   Up 7 hours             0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:3035->3035/tcp, :::3035->3035/tcp   decidim-only-form-app
+# 22304921b7eb   postgres:14-alpine                      "docker-entrypoint.s…"   7 hours ago   Up 7 hours (healthy)   0.0.0.0:5432->5432/tcp, :::5432->5432/tcp                                              decidim-module-only_forms-pg-1
+
+```
+
+2. In another terminal, run `docker exec -it 915e9fc474f2 bash`
+3. Run
+    - `tail -f $ROOT/log/development.log` to **access logs**
+    - `bundle exec rails restart` to **restart rails server AND keeps webpacker running**
+    - `cd $ROOT` to access the `development_app`
+    - `cd $ROOT/../decidim_module_only_forms` to access the module directory
+## Contributing
+
+See [Decidim](https://github.com/decidim/decidim).
+
+## License
+
+This engine is distributed under the [GNU AFFERO GENERAL PUBLIC LICENSE](LICENSE-AGPLv3.txt)
+
+<br /><br />
+<p align="center">
+    <img src="https://raw.githubusercontent.com/octree-gva/meta/main/decidim/static/octree_and_decidim.png" height="90" alt="Decidim Installation by Octree" />
+</p>

data/Rakefile

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "decidim/dev/common_rake"
+
+def install_module(path)
+  Dir.chdir(path) do
+    # system("bundle exec rake decidim_vocacity_gem_tasks:install:migrations")
+  end
+end
+
+def seed_db(path)
+  Dir.chdir(path) do
+    system("bundle exec rake db:seed")
+  end
+end
+
+desc "Prepare for testing"
+task :prepare_tests do
+  system("bundle add doorkeeper")
+  system("bundle exec rails generate doorkeeper:install")
+  system("bundle exec rails generate doorkeeper:migration")
+  # Remove previous existing db, and recreate one.
+  disable_docker_compose = ENV.fetch("DISABLED_DOCKER_COMPOSE", "false") == "true"
+  unless disable_docker_compose
+    system("sudo docker-compose down -v")
+    system("sudo docker-compose up -d --remove-orphans")
+  end
+  ENV["RAILS_ENV"] = "test"
+  databaseYml = {
+    "test" => {
+      "adapter" => "postgresql",
+      "encoding" => "unicode",
+      "host" => ENV.fetch("DATABASE_HOST", "localhost"),
+      "port" => ENV.fetch("DATABASE_PORT", "5432").to_i,
+      "username" => ENV.fetch("DATABASE_USERNAME", "decidim"),
+      "password" => ENV.fetch("DATABASE_PASSWORD", "TEST-baeGhi4Ohtahcee5eejoaxaiwaezaiGo"),
+      "database" => "decidim_test"
+    }
+  }
+  config_file = File.expand_path("spec/dummy/config/database.yml", __dir__)
+  File.open(config_file, "w") { |f| YAML.dump(databaseYml, f) }
+  Dir.chdir("spec/dummy") do
+     system("bundle exec rails db:migrate")
+   end
+end
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  Bundler.with_original_env do
+    generate_decidim_app(
+      "spec/dummy",
+        "--app_name",
+        "decidim_test",
+        "--path",
+        "../..",
+        "--skip_spring",
+        "--demo",
+        "--force_ssl",
+        "false",
+        "--locales",
+        "en,fr,es"
+    )
+  end
+  install_module("spec/dummy")
+  Rake::Task["prepare_tests"].invoke
+end
+
+desc "Generates a development app"
+task :development_app do
+  Bundler.with_original_env do
+    generate_decidim_app(
+      "development_app",
+      "--app_name",
+      "#{base_app_name}_development_app",
+      "--path",
+      "..",
+      "--recreate_db",
+      "--demo"
+    )
+  end
+
+  system("bin/rails generate doorkeeper:install")
+  system("bin/rails generate doorkeeper:migration")
+
+  install_module("development_app")
+  seed_db("development_app")
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # This command is executed when the user answers a Questionnaire.
+    class AnswerQuestionnaire < Decidim::Forms::Command
+      include ::Decidim::MultipleAttachmentsMethods
+
+      # 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? || user_already_answered?
+
+        answer_questionnaire
+
+        if @errors
+          reset_form_attachments
+          broadcast(:invalid)
+        else
+          broadcast(:ok)
+        end
+      end
+
+      attr_reader :form, :questionnaire, :current_user
+
+      private
+
+      # This method will add an error to the `add_documents` field only if there's
+      # any error in any other field or an error in another answer in the
+      # questionnaire. This is needed because when the form has
+      # an error, the attachments are lost, so we need a way to inform the user
+      # of this problem.
+      def reset_form_attachments
+        @form.responses.each do |answer|
+          answer.errors.add(:add_documents, :needs_to_be_reattached) if answer.has_attachments? || answer.has_error_in_attachments?
+        end
+      end
+
+      def answer_questionnaire
+        @main_form = @form
+        @errors = nil
+
+        Answer.transaction(requires_new: true) do
+          form.responses_by_step.flatten.select(&:display_conditions_fulfilled?).each do |form_answer|
+            answer = Answer.new(
+              user: @current_user,
+              questionnaire: @questionnaire,
+              question: form_answer.question,
+              body: form_answer.body,
+              session_token: form.context.session_token,
+              ip_hash: form.context.ip_hash
+            )
+
+            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,
+                decidim_question_matrix_row_id: choice.matrix_row_id,
+                position: choice.position
+              )
+            end
+
+            answer.save!
+
+            next unless form_answer.question.has_attachments?
+
+            # The attachments module expects `@form` to be the form with the
+            # attachments
+            @form = form_answer
+            @attached_to = answer
+
+            build_attachments
+
+            if attachments_invalid?
+              @errors = true
+              next
+            end
+
+            create_attachments if process_attachments?
+            document_cleanup!
+          end
+
+          @form = @main_form
+          raise ActiveRecord::Rollback if @errors
+        end
+      end
+
+      def user_already_answered?
+        return false if allow_multiple_answers?
+
+        questionnaire.answered_by?(current_user || form.context.session_token)
+      end
+
+      def allow_multiple_answers?
+        return current_settings.allow_multiple_answers if current_settings.respond_to?("allow_multiple_answers")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Forms
+    # maintains compatibility with v0.26 which uses Rectify
+    if defined? ::Decidim::Command
+      class Command < ::Decidim::Command
+      end
+    else
+      class Command < ::Rectify::Command
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# 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
+          helper Decidim::Forms::ApplicationHelper
+          include FormFactory
+
+          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)
+            render template: "decidim/forms/questionnaires/show"
+          end
+
+          def answer
+            enforce_permission_to_answer_questionnaire
+
+            @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
+                # 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: 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 false if survey allow multiple answers
+          # if not, return true if the current user (or session visitor) already answered the questionnaire
+          def visitor_already_answered?
+            return false if allow_multiple_answers?
+
+            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.
+          #
+          # 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
+
+          # 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
+            raise "#{self.class.name} is expected to implement #questionnaire_for"
+          end
+
+          private
+
+          def allow_multiple_answers?
+            return current_settings.allow_multiple_answers if current_settings.respond_to?("allow_multiple_answers")
+          end
+
+          def i18n_flashes_scope
+            "decidim.forms.questionnaires"
+          end
+
+          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
+
+          # You can implement this method in your controller to change the
+          # enforce_permission_to arguments.
+          def enforce_permission_to_answer_questionnaire
+            enforce_permission_to :answer, :questionnaire
+          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, length: 10)
+            tokenizer = Decidim::Tokenizer.new(salt: questionnaire.salt || questionnaire.id, length: length)
+            tokenizer.int_digest(id).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/surveys/survey.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Surveys
+    # The data store for a Survey in the Decidim::Surveys component.
+    class Survey < Surveys::ApplicationRecord
+      include Decidim::Resourceable
+      include Decidim::Forms::HasQuestionnaire
+      include Decidim::HasComponent
+
+      #component_manifest_name "surveys"
+
+      delegate :title, to: :questionnaire
+
+      validates :questionnaire, presence: true
+
+      def clean_after_publish?
+        component.settings.clean_after_publish?
+      end
+
+      def starts_at
+        component.settings.starts_at
+      end
+
+      def ends_at
+        component.settings.ends_at
+      end
+
+      def open?
+        return true if starts_at.blank? && ends_at.blank?
+        return true if ends_at.blank? && starts_at.past?
+        return true if starts_at.blank? && ends_at.future?
+
+        return Time.zone.now.between?(starts_at, ends_at) if starts_at.present? && ends_at.present?
+
+        false
+      end
+    end
+  end
+end

data/config/i18n-tasks.yml

@@ -0,0 +1,10 @@
+---
+
+base_locale: en
+locales: [en]
+
+ignore_unused:
+  - "decidim.components.only_forms.name"
+
+ignore_missing:
+  - decidim.participatory_processes.scopes.global

data/config/locales/en.yml

@@ -0,0 +1,27 @@
+---
+en:
+  decidim:
+    components:
+      only_forms:
+        name: Forms
+        settings:
+          global:
+            clean_after_publish: Delete answers when publishing the form
+            ends_at: Answers accepted until
+            ends_at_help: Leave blank for no specific date
+            scope_id: Scope
+            scopes_enabled: Scopes enabled
+            starts_at: Answers accepted from
+            starts_at_help: Leave blank for no specific date
+            announcement: Announcement
+          step:
+            allow_multiple_answers: Allow Multiple Answers
+            allow_answers: Allow answers
+            allow_unregistered: Allow unregistered users to answer the form
+            allow_unregistered_help: If active, no login will be required in order to answer the form. This may lead to poor or unreliable data and it will be more vulnerable to automated attacks. Use with caution!
+            announcement: Announcement
+    only_forms:
+      admin:
+          exports:
+            survey_user_answers: Forms participant answers      
+

data/config/locales/fr.yml

@@ -0,0 +1,27 @@
+---
+fr:
+  decidim:
+    components:
+      only_forms:
+        name: Formulaire
+        settings:
+          global:
+            clean_after_publish: Supprimer les réponses après publication du formulaire
+            ends_at: Réponses acceptées jusqu'à
+            ends_at_help: Laisser vide si pas de limite de date pour recevoir des réponses
+            scope_id: Scope
+            scopes_enabled: Scopes enabled
+            starts_at: Réponses acceptées depuis
+            starts_at_help: Laisser vide si pas de limite de date pour débuter la réception des réponses
+            announcement: Annonces
+          step:
+            allow_multiple_answers: Autoriser les utilisateurs à répondre plusieurs fois
+            allow_answers: Autoriser les réponses
+            allow_unregistered: Autoriser les réponses pour les visiteurs
+            allow_unregistered_help: Si ceci est actif, les visiteurs n'auront pas besoin de compte pour répondre.
+            announcement: Annonce
+    only_forms:
+      admin:
+          exports:
+            survey_user_answers: Réponses au formulaire      
+

data/config/locales/pt.yml

@@ -0,0 +1,27 @@
+---
+pt:
+  decidim:
+    components:
+      only_forms:
+        name: Formulario
+        settings:
+          global:
+            clean_after_publish: Deletar as respostas apos publicação
+            ends_at: Respostas aceitas até
+            ends_at_help: Deixa vazia se não tem limitas para receber respostas
+            scope_id: Scope
+            scopes_enabled: Scopes enabled
+            starts_at: Responstas ativas depois do
+            starts_at_help: Deixa vazia se não tem inicio para receber respostas
+            announcement: Anuncios
+          step:
+            allow_multiple_answers: Deixar os usarios responder mais que uma vez
+            allow_answers: Autorisar respostas
+            allow_unregistered: Autorisar respostas de visitores
+            allow_unregistered_help: Se isso esta ativos, pessoas sem contas poderam responder.
+            announcement: Anuncios
+    only_forms:
+      admin:
+          exports:
+            survey_user_answers: Responsas ao formulario
+

data/lib/decidim/only_forms/admin.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module OnlyForms
+    # This module contains all the domain logic associated to Decidim's OnlyForms
+    # component admin panel.
+    module Admin
+    end
+  end
+end

data/lib/decidim/only_forms/admin_engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module OnlyForms
+    # This is the engine that runs on the public interface of `OnlyForms`.
+    class AdminEngine < ::Rails::Engine
+      isolate_namespace Decidim::OnlyForms::Admin
+
+      paths["db/migrate"] = nil
+      paths["lib/tasks"] = nil
+
+      routes do
+        # Add admin engine routes here
+      end
+
+      def load_seed
+        nil
+      end
+    end
+  end
+end

data/lib/decidim/only_forms/component.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_dependency "decidim/components/namer"
+
+Decidim.register_component(:only_forms) do |component|
+  survey_component = Decidim.find_component_manifest("surveys")
+  component.attributes = survey_component.attributes.deep_dup
+  component.name = "only_forms"
+  
+  component.settings(:global) do |settings|
+    settings.attribute :scopes_enabled, type: :boolean, default: false
+    settings.attribute :scope_id, type: :scope
+    settings.attribute :starts_at, type: :time
+    settings.attribute :ends_at, type: :time
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+    settings.attribute :clean_after_publish, type: :boolean, default: true
+  end
+
+  component.settings(:step) do |settings|
+    settings.attribute :allow_answers, type: :boolean, default: false
+    settings.attribute :allow_unregistered, type: :boolean, default: false
+    settings.attribute :allow_multiple_answers, type: :boolean, default: true
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+  end
+
+  component.exports :survey_user_answers do |exports|
+    exports.collection do |f|
+      survey = Decidim::Surveys::Survey.find_by(component: f)
+      Decidim::Forms::QuestionnaireUserAnswers.for(survey.questionnaire)
+    end
+
+    exports.formats %w(CSV JSON Excel)
+
+    exports.serializer Decidim::Forms::UserAnswersSerializer
+  end
+
+  component.register_resource(:survey) do |resource|
+    resource.model_class_name = "Decidim::Surveys::Survey"
+  end
+  component
+end