decidim-collaborative_texts 0.31.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cebf8aafaaf331e3c5bc7afbc800b34301731a03a87b8e4fe4f83947803a4fa5
+  data.tar.gz: b43b11d0431395a03ce9cc86613fe251e017e2abad0ec4f4a4a410e548aceac4
+SHA512:
+  metadata.gz: ffc6eadae13b4b104fc799c10a01f3b4edd69b73935bf329a935ec7399aae055f67cd1614d28c12dc9e593edaa97e1b853f64aa8c8626a8fbad4003bde4a0203
+  data.tar.gz: 13bf2903c624058f03fbc4f2dde15f8180646c6dba273d80207f8c34f502cdd5a0244eb07a85467dfdcb85e4cc4037ea72e0c658b8a906bed5d3118affdea012

data/README.md

@@ -0,0 +1,24 @@
+# Decidim::CollaborativeTexts
+
+The Decidim::CollaborativeTexts is a component that allows users to collaboratively create and amend texts through the use of suggestions and comments.
+
+> **WARNING**
+> This module is under development and is not ready for usage yet.
+
+## Installation
+
+In order to install use this module, you need at least Decidim 0.31 to be installed.
+
+To install this module, run in your console:
+
+```bash
+bundle add decidim-collaborative_texts
+```
+
+## Contributing
+
+See [Decidim](https://github.com/decidim/decidim).
+
+## License
+
+See [Decidim](https://github.com/decidim/decidim).

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "decidim/dev/common_rake"

data/app/cells/decidim/collaborative_texts/document_cell.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "cell/partial"
+
+module Decidim
+  module CollaborativeTexts
+    # This cell renders the document card for an instance of a Document
+    # the default size is the List Card (:l)
+    class DocumentCell < Decidim::ViewModel
+      include Cell::ViewModel::Partial
+
+      def show
+        cell card_size, model, options
+      end
+
+      private
+
+      def card_size
+        "decidim/collaborative_texts/document_l"
+      end
+    end
+  end
+end

data/app/cells/decidim/collaborative_texts/document_l_cell.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # This cell renders the List (:l) post card
+    # for a given instance of a Post
+    class DocumentLCell < Decidim::CardLCell
+      private
+
+      def has_description?
+        false
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/admin/create_document.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This command is executed when the user creates a Document from the admin
+      # panel.
+      class CreateDocument < Decidim::Commands::CreateResource
+        fetch_form_attributes :title, :body, :coauthorships, :component
+
+        private
+
+        def resource_class = Decidim::CollaborativeTexts::Document
+
+        def extra_params
+          {
+            extra: {
+              body: form.body
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/admin/publish_document.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This command is executed when the user publishes an
+      # existing collaborative text document.
+      class PublishDocument < Decidim::Command
+        # Public: Initializes the command.
+        #
+        # document - Decidim::CollaborativeTexts::Document
+        # current_user - the user performing the action
+        def initialize(document, current_user)
+          @document = document
+          @current_user = current_user
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form was not valid and we could not proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if document.published?
+
+          transaction do
+            publish_document
+          end
+
+          broadcast(:ok, document)
+        end
+
+        private
+
+        attr_reader :document, :current_user
+
+        def publish_document
+          @document = Decidim.traceability.perform_action!(
+            :publish,
+            document,
+            current_user,
+            visibility: "all"
+          ) do
+            document.publish!
+            document
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/admin/unpublish_document.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This command is executed when the user unpublishes an
+      # existing collaborative text document.
+      class UnpublishDocument < Decidim::Command
+        # Public: Initializes the command.
+        #
+        # document - Decidim::CollaborativeTexts::Document
+        # current_user - the user performing the action
+        def initialize(document, current_user)
+          @document = document
+          @current_user = current_user
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form was not valid and we could not proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless document.published?
+
+          @document = Decidim.traceability.perform_action!(
+            :unpublish,
+            document,
+            current_user
+          ) do
+            document.unpublish!
+            document
+          end
+          broadcast(:ok, document)
+        end
+
+        private
+
+        attr_reader :document, :current_user
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/admin/update_document.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This command is executed when the user changes a Document from the admin
+      # panel.
+      class UpdateDocument < Decidim::Commands::UpdateResource
+        protected
+
+        def update_resource
+          # Attributes to the model Document
+          update_document_record!
+          # As traceability might not understand the (delegated) body attribute, we save it separately
+          if create_new_version?
+            create_draft_version!
+          else
+            update_version_record!
+          end
+        end
+
+        def create_new_version?
+          @create_new_version ||= resource.has_suggestions? && form.draft?
+        end
+
+        def update_document_record!
+          return unless form.title != resource.title || form.accepting_suggestions != resource.accepting_suggestions
+
+          # this is a safe-guard in case there are no coauthors
+          resource.coauthorships = form.coauthorships if resource.coauthorships.blank?
+
+          Decidim.traceability.update!(
+            resource,
+            current_user,
+            {
+              title: form.title,
+              accepting_suggestions: form.accepting_suggestions
+            },
+            **extra_document_params
+          )
+        end
+
+        # When the document is not a draft or it has no suggestions, we just update the current version
+        def update_version_record!
+          attributes = { draft: form.draft? }
+          attributes[:body] = form.body unless resource.has_suggestions?
+          Decidim.traceability.update!(
+            resource.current_version,
+            current_user,
+            attributes,
+            **extra_version_params
+          )
+        end
+
+        # A new version is necessary when the document has suggestions and we want a draft (so we can edit it)
+        # If we allow to edit a version with suggestions all the reference nodes to the DOM will be out of sync
+        # Note that we do not update the body in purpose, as it is edition is disabled in the UI
+        def create_draft_version!
+          Decidim.traceability.create!(
+            Decidim::CollaborativeTexts::Version,
+            current_user,
+            { document: resource, body: resource.body, draft: true },
+            **extra_version_params
+          )
+        end
+
+        def extra_document_params
+          {
+            extra: {
+              version_id: resource.current_version&.id,
+              version_number: current_version_number
+            }
+          }
+        end
+
+        def extra_version_params
+          {
+            extra: {
+              document_id: resource.id,
+              title: resource.title,
+              version_number: current_version_number
+            },
+            resource: {
+              title: resource.title
+            },
+            participatory_space: {
+              title: resource.participatory_space.title
+            }
+          }
+        end
+
+        def current_version_number
+          @current_version_number ||= begin
+            num = resource.current_version&.version_number || 1
+            create_new_version? ? num + 1 : num
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/admin/update_document_settings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This command is executed when the user changes a Document from the admin
+      # panel.
+      class UpdateDocumentSettings < Decidim::Commands::UpdateResource
+        fetch_form_attributes :announcement
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/create_suggestion.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # This command is executed when the user creates a Document from the admin
+    # panel.
+    class CreateSuggestion < Decidim::Commands::CreateResource
+      fetch_form_attributes :author, :document_version, :changeset
+
+      private
+
+      def resource_class = Decidim::CollaborativeTexts::Suggestion
+
+      def extra_params
+        {
+          extra: {
+            participatory_space: {
+              title: form.document&.participatory_space&.title
+            },
+            resource: {
+              title: form.document&.title
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/collaborative_texts/rollout.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # This command is executed when the user creates a Document from the admin
+    # panel.
+    class Rollout < Decidim::Commands::CreateResource
+      fetch_form_attributes :body, :document, :draft
+
+      # 1: add accepted suggestions authors as co-authors
+      # 2: transfer non-accepted suggestions to the new version
+      def run_after_hooks
+        process_accepted_suggestions
+        return if form.draft?
+
+        move_pending_suggestions
+      end
+
+      private
+
+      def resource_class = Decidim::CollaborativeTexts::Version
+
+      # move pending suggestions to the new version
+      # rubocop:disable Rails/SkipsModelValidations
+      def move_pending_suggestions
+        return if form.pending_suggestions.empty?
+
+        form.pending_suggestions.update_all(document_version_id: resource.id)
+      end
+      # rubocop:enable Rails/SkipsModelValidations
+
+      # Add as co-authors and change the status of the suggestions to accepted
+      def process_accepted_suggestions
+        affected_users = []
+        form.accepted_suggestions.each do |suggestion|
+          suggestion.accepted!
+          resource.document.add_coauthor suggestion.author
+          affected_users << suggestion.author
+        end
+
+        Decidim::EventsManager.publish(
+          event: "decidim.events.collaborative_texts.suggestion_accepted",
+          event_class: Decidim::CollaborativeTexts::SuggestionAcceptedEvent,
+          resource: resource.document,
+          affected_users: affected_users.uniq
+        )
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/collaborative_texts/admin/filterable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          private
+
+          def base_query
+            collection
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/collaborative_texts/admin/application_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      # This controller is the abstract class from which all other controllers of
+      # this engine inherit.
+      #
+      # Note that it inherits from `Decidim::Components::BaseController`, which
+      # override its layout and provide all kinds of useful methods.
+      class ApplicationController < Decidim::Admin::Components::BaseController
+      end
+    end
+  end
+end

data/app/controllers/decidim/collaborative_texts/admin/documents_controller.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    module Admin
+      class DocumentsController < Admin::ApplicationController
+        include Decidim::CollaborativeTexts::Admin::Filterable
+        include Decidim::Admin::HasTrashableResources
+
+        helper_method :documents, :document
+
+        def index
+          enforce_permission_to :read, :collaborative_text
+        end
+
+        def new
+          enforce_permission_to :create, :collaborative_text
+          @form = form(DocumentForm).instance
+        end
+
+        def create
+          enforce_permission_to :create, :collaborative_text
+          @form = form(DocumentForm).from_params(params)
+
+          CreateDocument.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("documents.create.success", scope: "decidim.collaborative_texts.admin")
+              redirect_to documents_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("documents.create.invalid", scope: "decidim.collaborative_texts.admin")
+              render action: "new", status: :unprocessable_entity
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to(:update, :collaborative_text, document:)
+          @form = form(DocumentForm).from_model(document)
+        end
+
+        def update
+          enforce_permission_to(:update, :collaborative_text, document:)
+          @form = form(DocumentForm).from_params(params)
+
+          UpdateDocument.call(@form, document) do
+            on(:ok) do
+              flash[:notice] = I18n.t("documents.update.success", scope: "decidim.collaborative_texts.admin")
+              redirect_to documents_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("documents.update.invalid", scope: "decidim.collaborative_texts.admin")
+              # This is a safe-guard in case there is no body coming from the POST request (as this attribute is read-only in certain cases)
+              @form.body = document.body if @form.body.blank?
+              render action: "edit", status: :unprocessable_entity
+            end
+          end
+        end
+
+        def edit_settings
+          enforce_permission_to(:update, :collaborative_text, document:)
+          @form = form(Admin::DocumentForm).from_model(document)
+        end
+
+        def update_settings
+          enforce_permission_to(:update, :collaborative_text, document:)
+          @form = form(Admin::DocumentForm).from_params(params)
+
+          UpdateDocumentSettings.call(@form, document) do
+            on(:ok) do
+              flash[:notice] = I18n.t("documents.update_settings.success", scope: "decidim.collaborative_texts.admin")
+              redirect_to documents_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("documents.update_settings.invalid", scope: "decidim.collaborative_texts.admin")
+              render action: "edit_settings", status: :unprocessable_entity
+            end
+          end
+        end
+
+        def publish
+          enforce_permission_to(:update, :collaborative_text, document:)
+          Decidim::CollaborativeTexts::Admin::PublishDocument.call(document, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("documents.publish.success", scope: "decidim.collaborative_texts.admin")
+              redirect_to documents_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("documents.publish.invalid", scope: "decidim.collaborative_texts.admin")
+              render action: "index", status: :unprocessable_entity
+            end
+          end
+        end
+
+        def unpublish
+          enforce_permission_to(:update, :collaborative_text, document:)
+          Decidim::CollaborativeTexts::Admin::UnpublishDocument.call(document, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("documents.unpublish.success", scope: "decidim.collaborative_texts.admin")
+              redirect_to documents_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("documents.unpublish.invalid", scope: "decidim.collaborative_texts.admin")
+              render action: "index", status: :unprocessable_entity
+            end
+          end
+        end
+
+        private
+
+        def trashable_deleted_resource_type
+          :document
+        end
+
+        def trashable_deleted_resource
+          @trashable_deleted_resource ||= collection.with_deleted.find_by(id: params[:id])
+        end
+
+        def trashable_deleted_collection
+          @trashable_deleted_collection = filtered_collection.only_deleted.deleted_at_desc
+        end
+
+        def documents
+          @documents ||= filtered_collection
+        end
+
+        def document
+          @document ||= collection.find(params[:id])
+        end
+
+        def collection
+          @collection ||= Document.where(component: current_component)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/collaborative_texts/application_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    # This controller is the abstract class from which all other controllers of
+    # this engine inherit.
+    #
+    # Note that it inherits from `Decidim::Components::Basecontroller`, which
+    # override its layout and provide all kinds of useful methods.
+    class ApplicationController < Decidim::Components::BaseController
+      helper Decidim::CollaborativeTexts::ApplicationHelper
+    end
+  end
+end

data/app/controllers/decidim/collaborative_texts/documents_controller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module CollaborativeTexts
+    class DocumentsController < Decidim::CollaborativeTexts::ApplicationController
+      include Decidim::Paginable
+      include Decidim::FormFactory
+      include Decidim::AjaxPermissionHandler
+
+      helper_method :documents, :document, :paginate_documents
+
+      def index; end
+
+      def show
+        raise ActionController::RoutingError, "Not Found" unless document
+      end
+
+      # roll out a new version of the document (only admins)
+      def update
+        enforce_permission_to(:rollout, :collaborative_text, document:)
+
+        @form = form(RolloutForm).from_params(params, document:)
+        Rollout.call(@form) do
+          on(:ok) do
+            render json: { redirect: @form.draft? ? presenter.edit : presenter.path }
+          end
+
+          on(:invalid) do
+            render json: { message: I18n.t("document.rollout.invalid", scope: "decidim.collaborative_texts", errors: @form.errors.full_messages) }, status: :unprocessable_entity
+          end
+        end
+      end
+
+      private
+
+      def document
+        @document ||= documents.find(params[:id])
+      end
+
+      def presenter
+        @presenter ||= Decidim::ResourceLocatorPresenter.new(document)
+      end
+
+      def documents
+        @documents ||= if current_user&.admin?
+                         Document.where(component: current_component)
+                       else
+                         Document.published.where(component: current_component)
+                       end
+      end
+
+      def paginate_documents
+        @paginate_documents ||= paginate(documents.enabled_desc)
+      end
+    end
+  end
+end