decidim-enhanced_textwork 1.0.0

data/app/controllers/concerns/decidim/enhanced_textwork/collaborative_orderable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module EnhancedTextwork
+    # Common logic to ordering resources
+    module CollaborativeOrderable
+      extend ActiveSupport::Concern
+
+      included do
+        include Decidim::Orderable
+
+        private
+
+        # Available orders based on enabled settings
+        def available_orders
+          @available_orders ||= begin
+            available_orders = %w(random recent)
+            available_orders << "most_contributed"
+            available_orders
+          end
+        end
+
+        def default_order
+          detect_order("most_contributed")
+        end
+
+        def reorder(drafts)
+          case order
+          when "random"
+            drafts.order_randomly(random_seed)
+          when "most_contributed"
+            drafts.order(contributions_count: :desc)
+          when "recent"
+            drafts.order(created_at: :desc)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/enhanced_textwork/orderable.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module EnhancedTextwork
+    # Common logic to ordering resources
+    module Orderable
+      extend ActiveSupport::Concern
+
+      included do
+        include Decidim::Orderable
+
+        private
+
+        # Available orders based on enabled settings
+        def available_orders
+          @available_orders ||= [default_order] + possible_orders.excluding(default_order)
+        end
+
+        def possible_orders
+          @possible_orders ||= begin
+            possible_orders = %w(random recent)
+            possible_orders << "most_voted" if most_voted_order_available?
+            possible_orders << "most_endorsed" if current_settings.endorsements_enabled?
+            possible_orders << "most_commented" if component_settings.comments_enabled?
+            possible_orders << "most_followed" << "with_more_authors"
+            possible_orders
+          end
+        end
+
+        def default_order
+          @default_order ||= begin
+            default_order = current_settings.default_sort_order.presence || component_settings.default_sort_order
+            return order_by_default if default_order == "default"
+
+            possible_orders.include?(default_order) ? default_order : order_by_default
+          end
+        end
+
+        def order_by_default
+          if order_by_votes?
+            "most_voted"
+          else
+            "random"
+          end
+        end
+
+        def most_voted_order_available?
+          current_settings.votes_enabled? && !current_settings.votes_hidden?
+        end
+
+        def order_by_votes?
+          most_voted_order_available? && current_settings.votes_blocked?
+        end
+
+        def reorder(paragraphs)
+          case order
+          when "most_commented"
+            paragraphs.left_joins(:comments).group(:id).order(Arel.sql("COUNT(decidim_comments_comments.id) DESC"))
+          when "most_endorsed"
+            paragraphs.order(endorsements_count: :desc)
+          when "most_followed"
+            paragraphs.left_joins(:follows).group(:id).order(Arel.sql("COUNT(decidim_follows.id) DESC"))
+          when "most_voted"
+            paragraphs.order(paragraph_votes_count: :desc)
+          when "random"
+            paragraphs.order_randomly(random_seed)
+          when "recent"
+            paragraphs.order(published_at: :desc)
+          when "with_more_authors"
+            paragraphs.order(coauthorships_count: :desc)
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/app/controllers/decidim/enhanced_textwork/admin/paragraph_answers_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This controller allows admins to answer paragraphs in a participatory process.
+      class ParagraphAnswersController < Admin::ApplicationController
+        helper_method :paragraph
+
+        helper EnhancedTextwork::ApplicationHelper
+        helper Decidim::EnhancedTextwork::Admin::ParagraphsHelper
+        helper Decidim::EnhancedTextwork::Admin::ParagraphRankingsHelper
+        helper Decidim::Messaging::ConversationHelper
+
+        def edit
+          enforce_permission_to :create, :paragraph_answer, paragraph: paragraph
+          @form = form(Admin::ParagraphAnswerForm).from_model(paragraph)
+        end
+
+        def update
+          enforce_permission_to :create, :paragraph_answer, paragraph: paragraph
+          @notes_form = form(ParagraphNoteForm).instance
+          @answer_form = form(Admin::ParagraphAnswerForm).from_params(params)
+
+          Admin::AnswerParagraph.call(@answer_form, paragraph) do
+            on(:ok) do
+              flash[:notice] = I18n.t("paragraphs.answer.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to paragraphs_path
+            end
+
+            on(:invalid) do
+              flash.keep[:alert] = I18n.t("paragraphs.answer.invalid", scope: "decidim.enhanced_textwork.admin")
+              render template: "decidim/enhanced_textwork/admin/paragraphs/show"
+            end
+          end
+        end
+
+        private
+
+        def skip_manage_component_permission
+          true
+        end
+
+        def paragraph
+          @paragraph ||= Paragraph.where(component: current_component).find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/paragraph_notes_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This controller allows admins to make private notes on paragraphs in a participatory process.
+      class ParagraphNotesController < Admin::ApplicationController
+        helper_method :paragraph
+
+        def create
+          enforce_permission_to :create, :paragraph_note, paragraph: paragraph
+          @form = form(ParagraphNoteForm).from_params(params)
+
+          CreateParagraphNote.call(@form, paragraph) do
+            on(:ok) do
+              flash[:notice] = I18n.t("paragraph_notes.create.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to paragraph_path(id: paragraph.id)
+            end
+
+            on(:invalid) do
+              flash.keep[:alert] = I18n.t("paragraph_notes.create.error", scope: "decidim.enhanced_textwork.admin")
+              redirect_to paragraph_path(id: paragraph.id)
+            end
+          end
+        end
+
+        private
+
+        def skip_manage_component_permission
+          true
+        end
+
+        def paragraph
+          @paragraph ||= Paragraph.where(component: current_component).find(params[:paragraph_id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/paragraphs_controller.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This controller allows admins to manage paragraphs in a participatory process.
+      class ParagraphsController < Admin::ApplicationController
+        include Decidim::ApplicationHelper
+        include Decidim::EnhancedTextwork::Admin::Filterable
+
+        helper EnhancedTextwork::ApplicationHelper
+        helper Decidim::EnhancedTextwork::Admin::ParagraphRankingsHelper
+        helper Decidim::Messaging::ConversationHelper
+        helper_method :paragraphs, :query, :form_presenter, :paragraph, :paragraph_ids
+        helper EnhancedTextwork::Admin::ParagraphBulkActionsHelper
+
+        def show
+          @notes_form = form(ParagraphNoteForm).instance
+          @answer_form = form(Admin::ParagraphAnswerForm).from_model(paragraph)
+        end
+
+        def new
+          enforce_permission_to :create, :paragraph
+          @form = form(Decidim::EnhancedTextwork::Admin::ParagraphForm).from_params(
+            attachment: form(AttachmentForm).from_params({})
+          )
+        end
+
+        def create
+          enforce_permission_to :create, :paragraph
+          @form = form(Decidim::EnhancedTextwork::Admin::ParagraphForm).from_params(params)
+
+          Admin::CreateParagraph.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("paragraphs.create.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to paragraphs_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("paragraphs.create.invalid", scope: "decidim.enhanced_textwork.admin")
+              render action: "new"
+            end
+          end
+        end
+
+        def update_category
+          enforce_permission_to :update, :paragraph_category
+
+          Admin::UpdateParagraphCategory.call(params[:category][:id], paragraph_ids) do
+            on(:invalid_category) do
+              flash.now[:error] = I18n.t(
+                "paragraphs.update_category.select_a_category",
+                scope: "decidim.enhanced_textwork.admin"
+              )
+            end
+
+            on(:invalid_paragraph_ids) do
+              flash.now[:alert] = I18n.t(
+                "paragraphs.update_category.select_a_paragraph",
+                scope: "decidim.enhanced_textwork.admin"
+              )
+            end
+
+            on(:update_paragraphs_category) do
+              flash.now[:notice] = update_paragraphs_bulk_response_successful(@response, :category)
+              flash.now[:alert] = update_paragraphs_bulk_response_errored(@response, :category)
+            end
+            respond_to do |format|
+              format.js
+            end
+          end
+        end
+
+        def publish_answers
+          enforce_permission_to :publish_answers, :paragraphs
+
+          Decidim::EnhancedTextwork::Admin::PublishAnswers.call(current_component, current_user, paragraph_ids) do
+            on(:invalid) do
+              flash.now[:alert] = t(
+                "paragraphs.publish_answers.select_a_paragraph",
+                scope: "decidim.enhanced_textwork.admin"
+              )
+            end
+
+            on(:ok) do
+              flash.now[:notice] = I18n.t("paragraphs.publish_answers.success", scope: "decidim")
+            end
+          end
+
+          respond_to do |format|
+            format.js
+          end
+        end
+
+        def update_scope
+          enforce_permission_to :update, :paragraph_scope
+
+          Admin::UpdateParagraphScope.call(params[:scope_id], paragraph_ids) do
+            on(:invalid_scope) do
+              flash.now[:error] = t(
+                "paragraphs.update_scope.select_a_scope",
+                scope: "decidim.enhanced_textwork.admin"
+              )
+            end
+
+            on(:invalid_paragraph_ids) do
+              flash.now[:alert] = t(
+                "paragraphs.update_scope.select_a_paragraph",
+                scope: "decidim.enhanced_textwork.admin"
+              )
+            end
+
+            on(:update_paragraphs_scope) do
+              flash.now[:notice] = update_paragraphs_bulk_response_successful(@response, :scope)
+              flash.now[:alert] = update_paragraphs_bulk_response_errored(@response, :scope)
+            end
+
+            respond_to do |format|
+              format.js
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :edit, :paragraph, paragraph: paragraph
+          @form = form(Admin::ParagraphForm).from_model(paragraph)
+        end
+
+        def update
+          enforce_permission_to :edit, :paragraph, paragraph: paragraph
+
+          @form = form(Admin::ParagraphForm).from_params(params)
+
+          Admin::UpdateParagraph.call(@form, @paragraph) do
+            on(:ok) do |_paragraph|
+              flash[:notice] = t("paragraphs.update.success", scope: "decidim")
+              redirect_to paragraphs_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = t("paragraphs.update.error", scope: "decidim")
+              render :edit
+            end
+          end
+        end
+
+        def destroy_draft
+          enforce_permission_to :edit, :paragraph, paragraph: draft
+
+          Admin::DestroyParagraph.call(draft) do
+            on(:ok) do
+              flash[:notice] = I18n.t("paragraphs.destroy_draft.success", scope: "decidim")
+              redirect_to participatory_texts_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("paragraphs.destroy_draft.error", scope: "decidim")
+              redirect_to participatory_texts_path
+            end
+          end
+        end
+
+        private
+
+        def collection
+          @collection ||= Paragraph.where(component: current_component).not_hidden.published
+        end
+
+        def paragraphs
+          @paragraphs ||= filtered_collection
+        end
+
+        def paragraph
+          @paragraph ||= collection.find(params[:id])
+        end
+
+        def paragraph_ids
+          @paragraph_ids ||= params[:paragraph_ids]
+        end
+
+        def drafts
+          Paragraph.where(component: current_component).drafts
+        end
+
+        def draft
+          @draft ||= drafts.find(params[:id])
+        end
+
+        def update_paragraphs_bulk_response_successful(response, subject)
+          return if response[:successful].blank?
+
+          case subject
+          when :category
+            t(
+              "paragraphs.update_category.success",
+              subject_name: response[:subject_name],
+              paragraphs: response[:successful].to_sentence,
+              scope: "decidim.enhanced_textwork.admin"
+            )
+          when :scope
+            t(
+              "paragraphs.update_scope.success",
+              subject_name: response[:subject_name],
+              paragraphs: response[:successful].to_sentence,
+              scope: "decidim.enhanced_textwork.admin"
+            )
+          end
+        end
+
+        def update_paragraphs_bulk_response_errored(response, subject)
+          return if response[:errored].blank?
+
+          case subject
+          when :category
+            t(
+              "paragraphs.update_category.invalid",
+              subject_name: response[:subject_name],
+              paragraphs: response[:errored].to_sentence,
+              scope: "decidim.enhanced_textwork.admin"
+            )
+          when :scope
+            t(
+              "paragraphs.update_scope.invalid",
+              subject_name: response[:subject_name],
+              paragraphs: response[:errored].to_sentence,
+              scope: "decidim.enhanced_textwork.admin"
+            )
+          end
+        end
+
+        def form_presenter
+          @form_presenter ||= present(@form, presenter_class: Decidim::EnhancedTextwork::ParagraphPresenter)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/paragraphs_imports_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      class ParagraphsImportsController < Admin::ApplicationController
+        def new
+          enforce_permission_to :import, :paragraphs
+
+          @form = form(Admin::ParagraphsImportForm).instance
+        end
+
+        def create
+          enforce_permission_to :import, :paragraphs
+
+          @form = form(Admin::ParagraphsImportForm).from_params(params)
+
+          Admin::ImportParagraphs.call(@form) do
+            on(:ok) do |paragraphs|
+              flash[:notice] = I18n.t("paragraphs_imports.create.success", scope: "decidim.enhanced_textwork.admin", number: paragraphs.length)
+              redirect_to EngineRouter.admin_proxy(current_component).root_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("paragraphs_imports.create.invalid", scope: "decidim.enhanced_textwork.admin")
+              render action: "new"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/paragraphs_merges_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      class ParagraphsMergesController < Admin::ApplicationController
+        def create
+          enforce_permission_to :merge, :paragraphs
+
+          @form = form(Admin::ParagraphsMergeForm).from_params(params)
+
+          Admin::MergeParagraphs.call(@form) do
+            on(:ok) do |_paragraph|
+              flash[:notice] = I18n.t("paragraphs_merges.create.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to EngineRouter.admin_proxy(@form.target_component).root_path
+            end
+
+            on(:invalid) do
+              flash[:alert_html] = Decidim::ValidationErrorsPresenter.new(
+                I18n.t("paragraphs_merges.create.invalid", scope: "decidim.enhanced_textwork.admin"),
+                @form
+              ).message
+              redirect_to EngineRouter.admin_proxy(current_component).root_path
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/paragraphs_splits_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      class ParagraphsSplitsController < Admin::ApplicationController
+        def create
+          enforce_permission_to :split, :paragraphs
+
+          @form = form(Admin::ParagraphsSplitForm).from_params(params)
+
+          Admin::SplitParagraphs.call(@form) do
+            on(:ok) do |_paragraph|
+              flash[:notice] = I18n.t("paragraphs_splits.create.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to EngineRouter.admin_proxy(@form.target_component).root_path
+            end
+
+            on(:invalid) do
+              flash[:alert_html] = Decidim::ValidationErrorsPresenter.new(
+                I18n.t("paragraphs_splits.create.invalid", scope: "decidim.enhanced_textwork.admin"),
+                @form
+              ).message
+              redirect_to EngineRouter.admin_proxy(current_component).root_path
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/enhanced_textwork/admin/participatory_texts_controller.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # This controller manages the participatory texts area.
+      class ParticipatoryTextsController < Admin::ApplicationController
+        helper_method :paragraph
+        helper ParticipatoryTextsHelper
+
+        def index
+          @drafts = Paragraph.where(component: current_component).drafts.order(:position)
+          @preview_form = form(Admin::PreviewParticipatoryTextForm).instance
+          @preview_form.from_models(@drafts)
+        end
+
+        def new_import
+          enforce_permission_to :manage, :participatory_texts
+          participatory_text = Decidim::EnhancedTextwork::ParticipatoryText.find_by(component: current_component)
+          @import = form(Admin::ImportParticipatoryTextForm).from_model(participatory_text)
+        end
+
+        def import
+          enforce_permission_to :manage, :participatory_texts
+          @import = form(Admin::ImportParticipatoryTextForm).from_params(params)
+
+          Admin::ImportParticipatoryText.call(@import) do
+            on(:ok) do
+              flash[:notice] = I18n.t("participatory_texts.import.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).participatory_texts_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("participatory_texts.import.invalid", scope: "decidim.enhanced_textwork.admin")
+              render action: "new_import"
+            end
+
+            on(:invalid_file) do
+              flash.now[:alert] = I18n.t("participatory_texts.import.invalid_file", scope: "decidim.enhanced_textwork.admin")
+              render action: "new_import"
+            end
+          end
+        end
+
+        def new_editor
+          enforce_permission_to :manage, :participatory_texts
+          participatory_text = Decidim::EnhancedTextwork::ParticipatoryText.find_by(component: current_component)
+          @import = form(Admin::ImportEditorParticipatoryTextForm).from_model(participatory_text)
+        end
+
+        def import_from_editor
+          enforce_permission_to :manage, :participatory_texts
+          @import = form(Admin::ImportEditorParticipatoryTextForm).from_params(params)
+
+          Admin::ImportFromEditorParticipatoryText.call(@import) do
+            on(:ok) do
+              flash[:notice] = I18n.t("participatory_texts.import.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).participatory_texts_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("participatory_texts.import.invalid", scope: "decidim.enhanced_textwork.admin")
+              render action: "new_editor"
+            end
+
+            on(:invalid_file) do
+              flash.now[:alert] = I18n.t("participatory_texts.import.invalid_file", scope: "decidim.enhanced_textwork.admin")
+              render action: "new_editor"
+            end
+          end
+        end
+
+        # When `save_draft` param exists, paragraphs are only saved.
+        # When no `save_draft` param is set, paragraphs are saved and published.
+        def update
+          enforce_permission_to :manage, :participatory_texts
+
+          form_params = params.require(:preview_participatory_text).permit!
+          @preview_form = form(Admin::PreviewParticipatoryTextForm).from_params(paragraphs: form_params[:paragraphs_attributes]&.values)
+
+          if params.has_key?("save_draft")
+            UpdateParticipatoryText.call(@preview_form) do
+              on(:ok) do
+                flash[:notice] = I18n.t("participatory_texts.update.success", scope: "decidim.enhanced_textwork.admin")
+                redirect_to EngineRouter.admin_proxy(current_component).participatory_texts_path
+              end
+
+              on(:invalid) do |failures|
+                alert_msg = [I18n.t("participatory_texts.publish.invalid", scope: "decidim.enhanced_textwork.admin")]
+                failures.each_pair { |id, msg| alert_msg << "ID:[#{id}] #{msg}" }
+                flash.now[:alert] = alert_msg.join("<br/>").html_safe
+                index
+                render action: "index"
+              end
+            end
+          else
+            PublishParticipatoryText.call(@preview_form) do
+              on(:ok) do
+                flash[:notice] = I18n.t("participatory_texts.publish.success", scope: "decidim.enhanced_textwork.admin")
+                redirect_to paragraphs_path
+              end
+
+              on(:invalid) do |failures|
+                alert_msg = [I18n.t("participatory_texts.publish.invalid", scope: "decidim.enhanced_textwork.admin")]
+                failures.each_pair { |id, msg| alert_msg << "ID:[#{id}] #{msg}" }
+                flash.now[:alert] = alert_msg.join("<br/>").html_safe
+                index
+                render action: "index"
+              end
+            end
+          end
+        end
+
+        # Removes all the unpublished paragraphs (drafts).
+        def discard
+          enforce_permission_to :manage, :participatory_texts
+
+          DiscardParticipatoryText.call(current_component) do
+            on(:ok) do
+              flash[:notice] = I18n.t("participatory_texts.discard.success", scope: "decidim.enhanced_textwork.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).participatory_texts_path
+            end
+          end
+        end
+      end
+    end
+  end
+end