decidim-proposals 0.20.1 → 0.21.0

data/app/commands/decidim/proposals/admin/publish_answers.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A command with all the business logic to publish many answers at once.
+      class PublishAnswers < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # component - The component that contains the answers.
+        # user - the Decidim::User that is publishing the answers.
+        # proposal_ids - the identifiers of the proposals with the answers to be published.
+        def initialize(component, user, proposal_ids)
+          @component = component
+          @user = user
+          @proposal_ids = proposal_ids
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if there are not proposals to publish.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless proposals.any?
+
+          proposals.each do |proposal|
+            transaction do
+              mark_proposal_as_answered(proposal)
+              notify_proposal_answer(proposal)
+            end
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :component, :user, :proposal_ids
+
+        def proposals
+          @proposals ||= Decidim::Proposals::Proposal
+                         .published
+                         .answered
+                         .state_not_published
+                         .where(component: component)
+                         .where(id: proposal_ids)
+        end
+
+        def mark_proposal_as_answered(proposal)
+          Decidim.traceability.perform_action!(
+            "publish_answer",
+            proposal,
+            user
+          ) do
+            proposal.update!(state_published_at: Time.current)
+          end
+        end
+
+        def notify_proposal_answer(proposal)
+          NotifyProposalAnswer.call(proposal, nil)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/admin/unassign_proposals_from_valuator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A command with all the business logic to unassign proposals from a given
+      # valuator.
+      class UnassignProposalsFromValuator < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          unassign_proposals
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form
+
+        def unassign_proposals
+          transaction do
+            form.proposals.flat_map do |proposal|
+              assignment = find_assignment(proposal)
+              unassign(assignment) if assignment
+            end
+          end
+        end
+
+        def find_assignment(proposal)
+          Decidim::Proposals::ValuationAssignment.find_by(
+            proposal: proposal,
+            valuator_role: form.valuator_role
+          )
+        end
+
+        def unassign(assignment)
+          Decidim.traceability.perform_action!(
+            :delete,
+            assignment,
+            form.current_user,
+            proposal_title: assignment.proposal.title
+          ) do
+            assignment.destroy!
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/admin/update_proposal_scope.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      #  A command with all the business logic when an admin batch updates proposals scope.
+      class UpdateProposalScope < Rectify::Command
+        include TranslatableAttributes
+        # Public: Initializes the command.
+        #
+        # scope_id - the scope id to update
+        # proposal_ids - the proposals ids to update.
+        def initialize(scope_id, proposal_ids)
+          @scope = Decidim::Scope.find_by id: scope_id
+          @proposal_ids = proposal_ids
+          @response = { scope_name: "", successful: [], errored: [] }
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :update_proposals_scope - when everything is ok, returns @response.
+        # - :invalid_scope - if the scope is blank.
+        # - :invalid_proposal_ids - if the proposal_ids is blank.
+        #
+        # Returns @response hash:
+        #
+        # - :scope_name - the translated_name of the scope assigned
+        # - :successful - Array of names of the updated proposals
+        # - :errored - Array of names of the proposals not updated because they already had the scope assigned
+        def call
+          return broadcast(:invalid_scope) if @scope.blank?
+          return broadcast(:invalid_proposal_ids) if @proposal_ids.blank?
+
+          update_proposals_scope
+
+          broadcast(:update_proposals_scope, @response)
+        end
+
+        private
+
+        attr_reader :scope, :proposal_ids
+
+        def update_proposals_scope
+          @response[:scope_name] = translated_attribute(scope.name, scope.organization)
+          Proposal.where(id: proposal_ids).find_each do |proposal|
+            if scope == proposal.scope
+              @response[:errored] << proposal.title
+            else
+              transaction do
+                update_proposal_scope proposal
+                notify_author proposal if proposal.coauthorships.any?
+              end
+              @response[:successful] << proposal.title
+            end
+          end
+        end
+
+        def update_proposal_scope(proposal)
+          proposal.update!(
+            scope: scope
+          )
+        end
+
+        def notify_author(proposal)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.proposal_update_scope",
+            event_class: Decidim::Proposals::Admin::UpdateProposalScopeEvent,
+            resource: proposal,
+            affected_users: proposal.notifiable_identities
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Proposals
+    module Admin
+      module Filterable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          helper Decidim::Proposals::Admin::FilterableHelper
+
+          private
+
+          # Comment about participatory_texts_enabled.
+          def base_query
+            return collection.order(:position) if current_component.settings.participatory_texts_enabled?
+
+            accessible_proposals_collection
+          end
+
+          def accessible_proposals_collection
+            return collection if current_participatory_space.user_roles(:valuator).where(user: current_user).empty?
+
+            collection.with_valuation_assigned_to(current_user, current_participatory_space)
+          end
+
+          def search_field_predicate
+            :id_string_or_title_cont
+          end
+
+          def filters
+            [
+              :is_emendation_true,
+              :state_eq,
+              :state_null,
+              :scope_id_eq,
+              :category_id_eq,
+              :valuator_role_ids_has
+            ]
+          end
+
+          def filters_with_values
+            {
+              is_emendation_true: %w(true false),
+              state_eq: proposal_states,
+              scope_id_eq: scope_ids_hash(scopes.top_level),
+              category_id_eq: category_ids_hash(categories.first_class),
+              valuator_role_ids_has: valuator_role_ids
+            }
+          end
+
+          # Can't user `super` here, because it does not belong to a superclass
+          # but to a concern.
+          def dynamically_translated_filters
+            [:scope_id_eq, :category_id_eq, :valuator_role_ids_has]
+          end
+
+          def valuator_role_ids
+            current_participatory_space.user_roles(:valuator).pluck(:id)
+          end
+
+          def translated_valuator_role_ids_has(valuator_role_id)
+            user_role = current_participatory_space.user_roles(:valuator).find_by(id: valuator_role_id)
+            user_role&.user&.name
+          end
+
+          # An Array<Symbol> of possible values for `state_eq` filter.
+          # Excludes the states that cannot be filtered with the ransack predicate.
+          # A link to filter by "Not answered" will be added in:
+          # Decidim::Proposals::Admin::FilterableHelper#extra_dropdown_submenu_options_items
+          def proposal_states
+            Proposal::POSSIBLE_STATES.without("not_answered")
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/proposals/admin/proposal_answers_controller.rb

@@ -7,30 +7,40 @@ module Decidim
       class ProposalAnswersController < Admin::ApplicationController
         helper_method :proposal
 
+        helper Proposals::ApplicationHelper
+        helper Decidim::Proposals::Admin::ProposalsHelper
+        helper Decidim::Proposals::Admin::ProposalRankingsHelper
+        helper Decidim::Messaging::ConversationHelper
+
         def edit
-          enforce_permission_to :create, :proposal_answer
+          enforce_permission_to :create, :proposal_answer, proposal: proposal
           @form = form(Admin::ProposalAnswerForm).from_model(proposal)
         end
 
         def update
-          enforce_permission_to :create, :proposal_answer
-          @form = form(Admin::ProposalAnswerForm).from_params(params)
+          enforce_permission_to :create, :proposal_answer, proposal: proposal
+          @notes_form = form(ProposalNoteForm).instance
+          @answer_form = form(Admin::ProposalAnswerForm).from_params(params)
 
-          Admin::AnswerProposal.call(@form, proposal) do
+          Admin::AnswerProposal.call(@answer_form, proposal) do
             on(:ok) do
               flash[:notice] = I18n.t("proposals.answer.success", scope: "decidim.proposals.admin")
               redirect_to proposals_path
             end
 
             on(:invalid) do
-              flash.now[:alert] = I18n.t("proposals.answer.invalid", scope: "decidim.proposals.admin")
-              render action: "edit"
+              flash.keep[:alert] = I18n.t("proposals.answer.invalid", scope: "decidim.proposals.admin")
+              render template: "decidim/proposals/admin/proposals/show"
             end
           end
         end
 
         private
 
+        def skip_manage_component_permission
+          true
+        end
+
         def proposal
           @proposal ||= Proposal.where(component: current_component).find(params[:id])
         end

data/app/controllers/decidim/proposals/admin/proposal_notes_controller.rb

@@ -7,30 +7,29 @@ module Decidim
       class ProposalNotesController < Admin::ApplicationController
         helper_method :proposal
 
-        def index
-          enforce_permission_to :create, :proposal_note
-          @form = form(ProposalNoteForm).instance
-        end
-
         def create
-          enforce_permission_to :create, :proposal_note
+          enforce_permission_to :create, :proposal_note, proposal: proposal
           @form = form(ProposalNoteForm).from_params(params)
 
           CreateProposalNote.call(@form, proposal) do
             on(:ok) do
               flash[:notice] = I18n.t("proposal_notes.create.success", scope: "decidim.proposals.admin")
-              redirect_to proposal_proposal_notes_path(proposal_id: proposal.id)
+              redirect_to proposal_path(id: proposal.id)
             end
 
             on(:invalid) do
-              flash.now[:alert] = I18n.t("proposal_notes.create.error", scope: "decidim.proposals.admin")
-              render :index
+              flash.keep[:alert] = I18n.t("proposal_notes.create.error", scope: "decidim.proposals.admin")
+              redirect_to proposal_path(id: proposal.id)
             end
           end
         end
 
         private
 
+        def skip_manage_component_permission
+          true
+        end
+
         def proposal
           @proposal ||= Proposal.where(component: current_component).find(params[:proposal_id])
         end

data/app/controllers/decidim/proposals/admin/proposals_controller.rb

@@ -6,9 +6,18 @@ module Decidim
       # This controller allows admins to manage proposals in a participatory process.
       class ProposalsController < Admin::ApplicationController
         include Decidim::ApplicationHelper
+        include Decidim::Proposals::Admin::Filterable
 
         helper Proposals::ApplicationHelper
-        helper_method :proposals, :query, :form_presenter
+        helper Decidim::Proposals::Admin::ProposalRankingsHelper
+        helper Decidim::Messaging::ConversationHelper
+        helper_method :proposals, :query, :form_presenter, :proposal, :proposal_ids
+        helper Proposals::Admin::ProposalBulkActionsHelper
+
+        def show
+          @notes_form = form(ProposalNoteForm).instance
+          @answer_form = form(Admin::ProposalAnswerForm).from_model(proposal)
+        end
 
         def new
           enforce_permission_to :create, :proposal
@@ -36,9 +45,8 @@ module Decidim
 
         def update_category
           enforce_permission_to :update, :proposal_category
-          @proposal_ids = params[:proposal_ids]
 
-          Admin::UpdateProposalCategory.call(params[:category][:id], params[:proposal_ids]) do
+          Admin::UpdateProposalCategory.call(params[:category][:id], proposal_ids) do
             on(:invalid_category) do
               flash.now[:error] = I18n.t(
                 "proposals.update_category.select_a_category",
@@ -54,9 +62,59 @@ module Decidim
             end
 
             on(:update_proposals_category) do
-              flash.now[:notice] = update_proposals_category_response_successful @response
-              flash.now[:alert] = update_proposals_category_response_errored @response
+              flash.now[:notice] = update_proposals_bulk_response_successful(@response, :category)
+              flash.now[:alert] = update_proposals_bulk_response_errored(@response, :category)
+            end
+            respond_to do |format|
+              format.js
+            end
+          end
+        end
+
+        def publish_answers
+          enforce_permission_to :publish_answers, :proposals
+
+          Decidim::Proposals::Admin::PublishAnswers.call(current_component, current_user, proposal_ids) do
+            on(:invalid) do
+              flash.now[:alert] = t(
+                "proposals.publish_answers.select_a_proposal",
+                scope: "decidim.proposals.admin"
+              )
+            end
+
+            on(:ok) do
+              flash.now[:notice] = I18n.t("proposals.publish_answers.success", scope: "decidim")
+            end
+          end
+
+          respond_to do |format|
+            format.js
+          end
+        end
+
+        def update_scope
+          enforce_permission_to :update, :proposal_scope
+
+          Admin::UpdateProposalScope.call(params[:scope_id], proposal_ids) do
+            on(:invalid_scope) do
+              flash.now[:error] = t(
+                "proposals.update_scope.select_a_scope",
+                scope: "decidim.proposals.admin"
+              )
+            end
+
+            on(:invalid_proposal_ids) do
+              flash.now[:alert] = t(
+                "proposals.update_scope.select_a_proposal",
+                scope: "decidim.proposals.admin"
+              )
             end
+
+            on(:update_proposals_scope) do
+              flash.now[:notice] = update_proposals_bulk_response_successful(@response, :scope)
+              flash.now[:alert] = update_proposals_bulk_response_errored(@response, :scope)
+            end
+
             respond_to do |format|
               format.js
             end
@@ -75,12 +133,12 @@ module Decidim
           @form = form(Admin::ProposalForm).from_params(params)
           Admin::UpdateProposal.call(@form, @proposal) do
             on(:ok) do |_proposal|
-              flash[:notice] = I18n.t("proposals.update.success", scope: "decidim")
+              flash[:notice] = t("proposals.update.success", scope: "decidim")
               redirect_to proposals_path
             end
 
             on(:invalid) do
-              flash.now[:alert] = I18n.t("proposals.update.error", scope: "decidim")
+              flash.now[:alert] = t("proposals.update.error", scope: "decidim")
               render :edit
             end
           end
@@ -88,42 +146,60 @@ module Decidim
 
         private
 
-        def query
-          @query ||= if current_component.settings.participatory_texts_enabled?
-                       Proposal.where(component: current_component).published.order(:position).ransack(params[:q])
-                     else
-                       Proposal.where(component: current_component).published.ransack(params[:q])
-                     end
+        def collection
+          @collection ||= Proposal.where(component: current_component).published
         end
 
         def proposals
-          @proposals ||= query.result.page(params[:page]).per(15)
+          @proposals ||= filtered_collection
         end
 
         def proposal
-          @proposal ||= Proposal.where(component: current_component).find(params[:id])
+          @proposal ||= collection.find(params[:id])
+        end
+
+        def proposal_ids
+          @proposal_ids ||= params[:proposal_ids]
         end
 
-        def update_proposals_category_response_successful(response)
+        def update_proposals_bulk_response_successful(response, subject)
           return if response[:successful].blank?
 
-          I18n.t(
-            "proposals.update_category.success",
-            category: response[:category_name],
-            proposals: response[:successful].to_sentence,
-            scope: "decidim.proposals.admin"
-          )
+          if subject == :category
+            t(
+              "proposals.update_category.success",
+              subject_name: response[:subject_name],
+              proposals: response[:successful].to_sentence,
+              scope: "decidim.proposals.admin"
+            )
+          elsif subject == :scope
+            t(
+              "proposals.update_scope.success",
+              subject_name: response[:subject_name],
+              proposals: response[:successful].to_sentence,
+              scope: "decidim.proposals.admin"
+            )
+          end
         end
 
-        def update_proposals_category_response_errored(response)
+        def update_proposals_bulk_response_errored(response, subject)
           return if response[:errored].blank?
 
-          I18n.t(
-            "proposals.update_category.invalid",
-            category: response[:category_name],
-            proposals: response[:errored].to_sentence,
-            scope: "decidim.proposals.admin"
-          )
+          if subject == :category
+            t(
+              "proposals.update_category.invalid",
+              subject_name: response[:subject_name],
+              proposals: response[:errored].to_sentence,
+              scope: "decidim.proposals.admin"
+            )
+          elsif subject == :scope
+            t(
+              "proposals.update_scope.invalid",
+              subject_name: response[:subject_name],
+              proposals: response[:errored].to_sentence,
+              scope: "decidim.proposals.admin"
+            )
+          end
         end
 
         def form_presenter