decidim-proposals 0.19.0 → 0.22.0

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

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      class ValuationAssignmentsController < Admin::ApplicationController
+        def create
+          enforce_permission_to :assign_to_valuator, :proposals
+
+          @form = form(Admin::ValuationAssignmentForm).from_params(params)
+
+          Admin::AssignProposalsToValuator.call(@form) do
+            on(:ok) do |_proposal|
+              flash[:notice] = I18n.t("valuation_assignments.create.success", scope: "decidim.proposals.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).root_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("valuation_assignments.create.invalid", scope: "decidim.proposals.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).root_path
+            end
+          end
+        end
+
+        def destroy
+          @form = form(Admin::ValuationAssignmentForm).from_params(destroy_params)
+
+          enforce_permission_to :unassign_from_valuator, :proposals, valuator: @form.valuator_user
+
+          Admin::UnassignProposalsFromValuator.call(@form) do
+            on(:ok) do |_proposal|
+              flash.keep[:notice] = I18n.t("valuation_assignments.delete.success", scope: "decidim.proposals.admin")
+              redirect_back fallback_location: EngineRouter.admin_proxy(current_component).root_path
+            end
+
+            on(:invalid) do
+              flash.keep[:alert] = I18n.t("valuation_assignments.delete.invalid", scope: "decidim.proposals.admin")
+              redirect_back fallback_location: EngineRouter.admin_proxy(current_component).root_path
+            end
+          end
+        end
+
+        private
+
+        def destroy_params
+          {
+            id: params.dig(:valuator_role, :id) || params[:id],
+            proposal_ids: params[:proposal_ids] || [params[:proposal_id]]
+          }
+        end
+
+        def skip_manage_component_permission
+          true
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/proposals/collaborative_drafts_controller.rb

@@ -171,12 +171,28 @@ module Decidim
       def default_filter_params
         {
           search_text: "",
-          category_id: "",
-          state: "open",
-          scope_id: nil,
+          category_id: default_filter_category_params,
+          state: %w(open),
+          scope_id: default_filter_scope_params,
           related_to: ""
         }
       end
+
+      def default_filter_category_params
+        return unless current_component.participatory_space.categories.any?
+
+        ["without"] + current_component.participatory_space.categories.map { |category| category.id.to_s }
+      end
+
+      def default_filter_scope_params
+        return unless current_component.participatory_space.scopes.any?
+
+        if current_component.participatory_space.scope
+          [current_component.participatory_space.scope.id] + current_component.participatory_space.scope.children.map { |scope| scope.id.to_s }
+        else
+          ["global"] + current_component.participatory_space.scopes.map { |scope| scope.id.to_s }
+        end
+      end
     end
   end
 end

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

@@ -13,7 +13,7 @@ module Decidim
       include Decidim::Proposals::Orderable
       include Paginable
 
-      helper_method :form_presenter
+      helper_method :proposal_presenter, :form_presenter
 
       before_action :authenticate_user!, only: [:new, :create, :complete]
       before_action :ensure_is_draft, only: [:compare, :complete, :preview, :publish, :edit_draft, :update_draft, :destroy_draft]
@@ -37,8 +37,7 @@ module Decidim
                        .results
                        .published
                        .not_hidden
-                       .includes(:category)
-                       .includes(:scope)
+                       .includes(:amendable, :category, :component, :resource_permission, :scope)
 
           @voted_proposals = if current_user
                                ProposalVote.where(
@@ -65,14 +64,14 @@ module Decidim
         if proposal_draft.present?
           redirect_to edit_draft_proposal_path(proposal_draft, component_id: proposal_draft.component.id, question_slug: proposal_draft.component.participatory_space.slug)
         else
-          @form = form(ProposalWizardCreateStepForm).from_params({})
+          @form = form(ProposalWizardCreateStepForm).from_params(body: translated_proposal_body_template)
         end
       end
 
       def create
         enforce_permission_to :create, :proposal
         @step = :step_1
-        @form = form(ProposalWizardCreateStepForm).from_params(params)
+        @form = form(ProposalWizardCreateStepForm).from_params(proposal_creation_params)
 
         CreateProposal.call(@form, current_user) do
           on(:ok) do |proposal|
@@ -212,16 +211,39 @@ module Decidim
       def default_filter_params
         {
           search_text: "",
-          origin: "all",
-          activity: "",
-          category_id: "",
-          state: "except_rejected",
-          scope_id: nil,
+          origin: default_filter_origin_params,
+          activity: "all",
+          category_id: default_filter_category_params,
+          state: %w(accepted evaluating not_answered),
+          scope_id: default_filter_scope_params,
           related_to: "",
           type: "all"
         }
       end
 
+      def default_filter_origin_params
+        filter_origin_params = %w(citizens meeting)
+        filter_origin_params << "official" if component_settings.official_proposals_enabled
+        filter_origin_params << "user_group" if current_organization.user_groups_enabled?
+        filter_origin_params
+      end
+
+      def default_filter_category_params
+        return "all" unless current_component.participatory_space.categories.any?
+
+        ["all"] + current_component.participatory_space.categories.pluck(:id).map(&:to_s)
+      end
+
+      def default_filter_scope_params
+        return "all" unless current_component.participatory_space.scopes.any?
+
+        if current_component.participatory_space.scope
+          ["all", current_component.participatory_space.scope.id] + current_component.participatory_space.scope.children.map { |scope| scope.id.to_s }
+        else
+          %w(all global) + current_component.participatory_space.scopes.pluck(:id).map(&:to_s)
+        end
+      end
+
       def proposal_draft
         Proposal.from_all_author_identities(current_user).not_hidden.only_amendables
                 .where(component: current_component).find_by(published_at: nil)
@@ -245,6 +267,10 @@ module Decidim
         Proposal.only_visible_emendations_for(current_user, current_component).published.include?(@proposal)
       end
 
+      def proposal_presenter
+        @proposal_presenter ||= present(@proposal)
+      end
+
       def form_proposal_params
         form(ProposalForm).from_params(params)
       end
@@ -258,7 +284,7 @@ module Decidim
       end
 
       def form_attachment_new
-        form(AttachmentForm).from_params({})
+        form(AttachmentForm).from_model(Attachment.new)
       end
 
       def edit_form
@@ -271,6 +297,14 @@ module Decidim
       def set_participatory_text
         @participatory_text = Decidim::Proposals::ParticipatoryText.find_by(component: current_component)
       end
+
+      def translated_proposal_body_template
+        translated_attribute component_settings.new_proposal_body_template
+      end
+
+      def proposal_creation_params
+        params[:proposal].merge(body_template: translated_proposal_body_template)
+      end
     end
   end
 end

data/app/controllers/decidim/proposals/versions_controller.rb

@@ -5,23 +5,16 @@ module Decidim
     # Exposes Proposals versions so users can see how a Proposal/CollaborativeDraft
     # has been updated through time.
     class VersionsController < Decidim::Proposals::ApplicationController
-      helper Decidim::TraceabilityHelper
-      helper_method :current_version, :item
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceVersionsConcern
 
-      private
-
-      def item
-        @item ||= if params[:proposal_id]
-                    Proposal.where(component: current_component).find(params[:proposal_id])
-                  else
-                    CollaborativeDraft.where(component: current_component).find(params[:collaborative_draft_id])
-                  end
-      end
-
-      def current_version
-        return nil unless params[:id].to_i.positive?
-
-        @current_version ||= item.versions[params[:id].to_i - 1]
+      def versioned_resource
+        @versioned_resource ||=
+          if params[:proposal_id]
+            present(Proposal.where(component: current_component).find(params[:proposal_id]))
+          else
+            CollaborativeDraft.where(component: current_component).find(params[:collaborative_draft_id])
+          end
       end
     end
   end

data/app/events/decidim/proposals/admin/proposal_note_created_event.rb

@@ -0,0 +1,27 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      class ProposalNoteCreatedEvent < Decidim::Events::SimpleEvent
+        include Rails.application.routes.mounted_helpers
+
+        i18n_attributes :admin_proposal_info_url, :admin_proposal_info_path
+
+        def admin_proposal_info_path
+          ResourceLocatorPresenter.new(resource).show
+        end
+
+        def admin_proposal_info_url
+          decidim_admin_participatory_process_proposals.proposal_url(resource, resource.component.mounted_params)
+        end
+
+        private
+
+        def organization
+          @organization ||= component.participatory_space.organization
+        end
+      end
+    end
+  end
+end