decidim-proposals 0.29.2 → 0.30.0.rc2

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A module with common methods of proposal notes commands
+      module ProposalNotesMethods
+        private
+
+        def parsed_body
+          @parsed_body ||= Decidim::ContentProcessor.parse_with_processor(:user, form.body, current_organization: form.current_organization)
+        end
+
+        def mentioned_users
+          @mentioned_users ||= parsed_body.metadata[:user].users
+        end
+
+        def rewritten_body
+          @rewritten_body ||= parsed_body.rewrite
+        end
+
+        def proposal_valuators
+          @proposal_valuators ||= Decidim::Proposals::ValuationAssignment.where(proposal:).filter_map do |assignment|
+            assignment.valuator unless assignment.valuator == form.current_user
+          end
+        end
+
+        def admins
+          @admins ||= Decidim::User.org_admins_except_me(form.current_user).all
+        end
+
+        def space_admins
+          @space_admins ||= proposal.participatory_space.user_roles("admin").includes(:user).filter_map do |role|
+            role.user unless role.user == form.current_user
+          end
+        end
+
+        def mentioned_admins_or_valuators
+          mentioned_users.select do |user|
+            admins.exists?(user.id) ||
+              space_admins.include?(user) ||
+              proposal_valuators.include?(user)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      # A command with all the business logic when an admin creates a private note proposal reply.
+      class ReplyProposalNote < Decidim::Command
+        include ProposalNotesMethods
+
+        # Public: Initializes the command.
+        #
+        # form   - A form object with the params.
+        # parent - the note to reply.
+        def initialize(form, parent)
+          @form = form
+          @parent = parent
+          @proposal = parent.proposal
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid, together with the note proposal.
+        # - :invalid if the form was not valid and we could not proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid? || invalid_parent?
+
+          create_proposal_note_reply
+          notify_parent_author
+          notify_mentioned
+
+          broadcast(:ok, proposal_note)
+        end
+
+        private
+
+        attr_reader :form, :proposal_note, :parent, :proposal
+
+        def invalid_parent?
+          parent.blank? || parent.reply?
+        end
+
+        def create_proposal_note_reply
+          @proposal_note = Decidim.traceability.create!(
+            ProposalNote,
+            form.current_user,
+            {
+              body: rewritten_body,
+              proposal:,
+              parent:,
+              author: form.current_user
+            },
+            resource: {
+              title: proposal.title
+            }
+          )
+        end
+
+        def parent_author
+          @parent_author ||= parent.author
+        end
+
+        def notify_parent_author
+          return if form.current_user == parent_author
+
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.admin.proposal_note_replied",
+            event_class: Decidim::Proposals::Admin::ProposalNoteCreatedEvent,
+            resource: proposal,
+            affected_users: [parent_author],
+            extra: { note_author_id: form.current_user.id }
+          )
+        end
+
+        def notify_mentioned
+          affected_users = mentioned_admins_or_valuators - [parent_author]
+
+          return if affected_users.blank?
+
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.admin.proposal_note_mentioned",
+            event_class: Decidim::Proposals::Admin::ProposalNoteCreatedEvent,
+            resource: proposal,
+            affected_users:,
+            extra: { note_author_id: form.current_user.id }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -53,13 +53,13 @@ module Decidim
           )
 
           proposals_to_link = links_for(original_proposal)
-          split_proposal.link_resources(proposals_to_link, "copied_from_component")
+          split_proposal.link_resources(proposals_to_link, "splitted_from_component")
         end
 
         def links_for(proposal)
           return proposal unless form.same_component?
 
-          proposal.linked_resources(:proposals, "copied_from_component")
+          proposal.linked_resources(:proposals, "splitted_from_component")
         end
       end
     end

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

@@ -5,8 +5,7 @@ module Decidim
     module Admin
       # A command with all the business logic when a user updates a proposal.
       class UpdateProposal < Decidim::Command
-        include ::Decidim::AttachmentMethods
-        include GalleryMethods
+        include ::Decidim::MultipleAttachmentsMethods
         include HashtagsMethods
 
         # Public: Initializes the command.
@@ -31,23 +30,15 @@ module Decidim
           delete_attachment(form.attachment) if delete_attachment?
 
           if process_attachments?
-            @proposal.attachments.destroy_all
-
-            build_attachment
-            return broadcast(:invalid) if attachment_invalid?
-          end
-
-          if process_gallery?
-            build_gallery
-            return broadcast(:invalid) if gallery_invalid?
+            build_attachments
+            return broadcast(:invalid) if attachments_invalid?
           end
 
           transaction do
             update_proposal
             update_proposal_author
-            create_gallery if process_gallery?
-            create_attachment(weight: first_attachment_weight) if process_attachments?
-            photo_cleanup!
+            document_cleanup!(include_all_attachments: true)
+            create_attachments(first_weight: first_attachment_weight) if process_attachments?
           end
 
           broadcast(:ok, proposal)
@@ -69,8 +60,7 @@ module Decidim
             form.current_user,
             title: parsed_title,
             body: parsed_body,
-            category: form.category,
-            scope: form.scope,
+            taxonomizations: form.taxonomizations,
             address: form.address,
             latitude: form.latitude,
             longitude: form.longitude,
@@ -90,6 +80,10 @@ module Decidim
 
           proposal.photos.count
         end
+
+        def delete_attachment?
+          @form.attachment&.delete_file.present?
+        end
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    module Admin
+      #  A command with all the business logic when an admin batch updates proposals taxonomies.
+      class UpdateProposalTaxonomies < UpdateResourcesTaxonomies
+        include TranslatableAttributes
+        # Public: Initializes the command.
+        #
+        # taxonomy_ids - the taxonomy ids to update
+        # proposal_ids - the proposals ids to update.
+        def initialize(taxonomy_ids, proposal_ids, organization)
+          super(taxonomy_ids, Decidim::Proposals::Proposal.where(id: proposal_ids), organization)
+        end
+
+        def run_after_hooks(resource)
+          notify_author(resource) if resource.coauthorships.any?
+        end
+
+        private
+
+        def notify_author(proposal)
+          Decidim::EventsManager.publish(
+            event: "decidim.events.proposals.proposal_update_taxonomies",
+            event_class: Decidim::Proposals::UpdateProposalTaxonomiesEvent,
+            resource: proposal,
+            affected_users: proposal.notifiable_identities
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/cancel_coauthorship.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user cancels an invitation to be a coauthor.
+    class CancelCoauthorship < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        @proposal.coauthor_invitations_for(@coauthor).destroy_all
+
+        broadcast(:ok)
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/create_collaborative_draft.rb

@@ -63,8 +63,7 @@ module Decidim
           draft = CollaborativeDraft.new(
             title: title_with_hashtags,
             body: body_with_hashtags,
-            category: form.category,
-            scope: form.scope,
+            taxonomizations: form.taxonomizations,
             component: form.component,
             address: form.address,
             latitude: form.latitude,

data/app/commands/decidim/proposals/create_proposal.rb

@@ -82,8 +82,7 @@ module Decidim
               component: form.component
             )
 
-            proposal.category = form.category if form.category_id.present?
-            proposal.scope = form.scope if form.scope_id.present?
+            proposal.taxonomizations = form.taxonomizations if form.taxonomizations.present?
             proposal.documents = form.documents if form.documents.present?
             proposal.address = form.address if form.has_address? && !form.geocoded?
             proposal.add_coauthor(@current_user, user_group:)

data/app/commands/decidim/proposals/invite_coauthor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user invites a coauthor to a proposal
+    class InviteCoauthor < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        transaction do
+          generate_notifications
+        end
+
+        broadcast(:ok)
+      end
+
+      private
+
+      def generate_notifications
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.coauthor_invited",
+          event_class: Decidim::Proposals::CoauthorInvitedEvent,
+          resource: @proposal,
+          affected_users: [@coauthor]
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/publish_collaborative_draft.rb

@@ -62,7 +62,6 @@ module Decidim
         fields[:title] = { I18n.locale => parsed_title }
         fields[:body] = { I18n.locale => parsed_body }
         fields[:component] = @collaborative_draft.component
-        fields[:scope] = @collaborative_draft.scope
         fields[:address] = @collaborative_draft.address
         fields[:published_at] = Time.current
 
@@ -78,7 +77,7 @@ module Decidim
         ) do
           new_proposal = Proposal.new(proposal_attributes)
           new_proposal.coauthorships = @collaborative_draft.coauthorships
-          new_proposal.category = @collaborative_draft.category
+          new_proposal.taxonomies = @collaborative_draft.taxonomies
           new_proposal.attachments = @collaborative_draft.attachments
           new_proposal.save!
           new_proposal

data/app/commands/decidim/proposals/reject_coauthorship.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Proposals
+    # A command with all the business logic when a user rejects and invitation to be a proposal co-author
+    class RejectCoauthorship < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # proposal     - The proposal to add a coauthor to.
+      # coauthor - The user to invite as coauthor.
+      def initialize(proposal, coauthor)
+        @proposal = proposal
+        @coauthor = coauthor
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the proposal.
+      # - :invalid if the coauthor is not valid.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless @coauthor
+        return broadcast(:invalid) if @proposal.authors.include?(@coauthor)
+
+        @proposal.coauthor_invitations_for(@coauthor).destroy_all
+        generate_notifications
+
+        broadcast(:ok)
+      end
+
+      private
+
+      def generate_notifications
+        # notify the author that the co-author has rejected the invitation
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.coauthor_rejected_invite",
+          event_class: Decidim::Proposals::CoauthorRejectedInviteEvent,
+          resource: @proposal,
+          affected_users: @proposal.authors,
+          extra: { coauthor_id: @coauthor.id }
+        )
+
+        # notify the co-author of his own decision
+        Decidim::EventsManager.publish(
+          event: "decidim.events.proposals.rejected_coauthorship",
+          event_class: Decidim::Proposals::RejectedCoauthorshipEvent,
+          resource: @proposal,
+          affected_users: [@coauthor]
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/update_collaborative_draft.rb

@@ -61,8 +61,7 @@ module Decidim
         {
           title: title_with_hashtags,
           body: body_with_hashtags,
-          category: form.category,
-          scope: form.scope,
+          taxonomizations: form.taxonomizations,
           address: form.address,
           latitude: form.latitude,
           longitude: form.longitude

data/app/commands/decidim/proposals/update_proposal.rb

@@ -98,8 +98,7 @@ module Decidim
           body: {
             I18n.locale => body_with_hashtags
           },
-          category: form.category,
-          scope: form.scope,
+          taxonomizations: form.taxonomizations,
           address: form.address,
           latitude: form.latitude,
           longitude: form.longitude

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

@@ -19,7 +19,11 @@ module Decidim
           def base_query
             return collection.order(:position) if current_component.settings.participatory_texts_enabled?
 
-            accessible_proposals_collection
+            return accessible_proposals_collection unless taxonomy_order_or_search?
+
+            # this is a trick to avoid duplicates when using search in associations as suggested in:
+            # https://activerecord-hackery.github.io/ransack/going-further/other-notes/#problem-with-distinct-selects
+            accessible_proposals_collection.includes(:taxonomies).joins(:taxonomies)
           end
 
           def accessible_proposals_collection

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Proposals
+    module Admin
+      module NeedsInterpolations
+        extend ActiveSupport::Concern
+
+        included do
+          def populate_interpolations(text, proposal)
+            return populate_string_interpolations(text, proposal) if text.is_a?(String)
+
+            populate_hash_interpolations(text, proposal)
+          end
+
+          def populate_hash_interpolations(hash, proposal)
+            return hash unless hash.is_a?(Hash)
+
+            hash.transform_values do |value|
+              populate_interpolations(value, proposal)
+            end
+          end
+
+          def populate_string_interpolations(value, proposal)
+            value = value.gsub("%{organization}", translated_attribute(proposal.organization.name))
+            value = value.gsub("%{name}", author_name(proposal))
+            value.gsub("%{admin}", current_user.name)
+          end
+
+          def author_name(proposal)
+            name = proposal.creator_author.try(:title) || proposal.creator_author.try(:name)
+            translated_attribute(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,10 @@ module Decidim
     module Admin
       # This controller allows admins to answer proposals in a participatory process.
       class ProposalAnswersController < Admin::ApplicationController
+        include ActionView::Helpers::SanitizeHelper
+        include Decidim::Proposals::Admin::NeedsInterpolations
+        include Decidim::Proposals::Admin::Filterable
+
         helper_method :proposal
 
         helper Proposals::ApplicationHelper
@@ -14,13 +18,13 @@ module Decidim
 
         def edit
           enforce_permission_to(:create, :proposal_answer, proposal:)
-          @form = form(Admin::ProposalAnswerForm).from_model(proposal)
+          @form = form(ProposalAnswerForm).from_model(proposal)
         end
 
         def update
           enforce_permission_to(:create, :proposal_answer, proposal:)
           @notes_form = form(ProposalNoteForm).instance
-          @answer_form = form(Admin::ProposalAnswerForm).from_params(params)
+          @answer_form = form(ProposalAnswerForm).from_params(params)
 
           Admin::AnswerProposal.call(@answer_form, proposal) do
             on(:ok) do
@@ -35,6 +39,33 @@ module Decidim
           end
         end
 
+        def update_multiple_answers
+          valid_proposals = []
+          failed_proposals = []
+          proposals.each do |proposal|
+            proposal_answer_form = answer_form(proposal)
+            if allowed_to?(:create, :proposal_answer, proposal:) && proposal_answer_form.valid? && !proposal.emendation?
+              valid_proposals << proposal.id
+              ProposalAnswerJob.perform_later(proposal, proposal_answer_form.attributes, { current_organization:, current_component:, current_user: })
+            else
+              failed_proposals << proposal.id
+            end
+          end
+
+          if failed_proposals.any?
+            flash[:alert] =
+              t("proposals.answer.bulk_answer_error", scope: "decidim.proposals.admin", template: strip_tags(translated_attribute(template&.name)),
+                                                      proposals: failed_proposals.join(", "))
+          end
+          if valid_proposals.any?
+            flash[:notice] =
+              I18n.t("proposals.answer.bulk_answer_success", scope: "decidim.proposals.admin", template: strip_tags(translated_attribute(template&.name)),
+                                                             count: valid_proposals.count)
+          end
+
+          redirect_to EngineRouter.admin_proxy(current_component).root_path
+        end
+
         private
 
         def skip_manage_component_permission
@@ -44,6 +75,28 @@ module Decidim
         def proposal
           @proposal ||= Proposal.where(component: current_component).find(params[:id])
         end
+
+        def proposals
+          @proposals ||= Proposal.where(component: current_component).where(id: params[:proposal_ids])
+        end
+
+        def collection
+          @collection ||= Proposal.where(component: current_component).not_hidden.published
+        end
+
+        def template
+          return unless Decidim.module_installed?(:templates)
+
+          @template ||= Decidim::Templates::Template.find_by(id: params[:template][:template_id])
+        end
+
+        def answer_form(proposal)
+          form(ProposalAnswerForm).from_params(answer: populate_interpolations(template&.description, proposal), internal_state: proposal_state&.token)
+        end
+
+        def proposal_state
+          @proposal_state ||= Decidim::Proposals::ProposalState.find_by(id: template&.field_values&.dig("proposal_state_id"))
+        end
       end
     end
   end

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

@@ -7,6 +7,24 @@ module Decidim
       class ProposalNotesController < Admin::ApplicationController
         helper_method :proposal
 
+        def reply
+          enforce_permission_to(:create, :proposal_note, proposal:)
+          parent_note = proposal.notes.find(params[:id])
+          @form = form(ProposalNoteForm).from_params(params)
+
+          ReplyProposalNote.call(@form, parent_note) do
+            on(:ok) do
+              flash[:notice] = I18n.t("proposal_notes.reply.success", scope: "decidim.proposals.admin")
+              redirect_to proposal_path(id: proposal.id)
+            end
+
+            on(:invalid) do
+              flash.keep[:alert] = I18n.t("proposal_notes.reply.error", scope: "decidim.proposals.admin")
+              redirect_to proposal_path(id: proposal.id)
+            end
+          end
+        end
+
         def create
           enforce_permission_to(:create, :proposal_note, proposal:)
           @form = form(ProposalNoteForm).from_params(params)